Старт
This commit is contained in:
AidarKC
commit
ff9301eddb
43
.gitignore
vendored
Normal file
43
.gitignore
vendored
Normal file
@ -0,0 +1,43 @@
|
||||
.gradle
|
||||
build/
|
||||
!gradle/wrapper/gradle-wrapper.jar
|
||||
!**/src/main/**/build/
|
||||
!**/src/test/**/build/
|
||||
.kotlin
|
||||
|
||||
### IntelliJ IDEA ###
|
||||
.idea/modules.xml
|
||||
.idea/jarRepositories.xml
|
||||
.idea/compiler.xml
|
||||
.idea/libraries/
|
||||
*.iws
|
||||
*.iml
|
||||
*.ipr
|
||||
out/
|
||||
!**/src/main/**/out/
|
||||
!**/src/test/**/out/
|
||||
|
||||
### Eclipse ###
|
||||
.apt_generated
|
||||
.classpath
|
||||
.factorypath
|
||||
.project
|
||||
.settings
|
||||
.springBeans
|
||||
.sts4-cache
|
||||
bin/
|
||||
!**/src/main/**/bin/
|
||||
!**/src/test/**/bin/
|
||||
|
||||
### NetBeans ###
|
||||
/nbproject/private/
|
||||
/nbbuild/
|
||||
/dist/
|
||||
/nbdist/
|
||||
/.nb-gradle/
|
||||
|
||||
### VS Code ###
|
||||
.vscode/
|
||||
|
||||
### Mac OS ###
|
||||
.DS_Store
|
||||
8
.idea/.gitignore
generated
vendored
Normal file
8
.idea/.gitignore
generated
vendored
Normal file
@ -0,0 +1,8 @@
|
||||
# Default ignored files
|
||||
/shelf/
|
||||
/workspace.xml
|
||||
# Editor-based HTTP Client requests
|
||||
/httpRequests/
|
||||
# Datasource local storage ignored files
|
||||
/dataSources/
|
||||
/dataSources.local.xml
|
||||
10
.idea/artifacts/server_jar.xml
generated
Normal file
10
.idea/artifacts/server_jar.xml
generated
Normal file
@ -0,0 +1,10 @@
|
||||
<component name="ArtifactManager">
|
||||
<artifact type="jar" build-on-make="true" name="server:jar">
|
||||
<output-path>$PROJECT_DIR$/out/artifacts/server_jar</output-path>
|
||||
<root id="archive" name="server.jar">
|
||||
<element id="directory" name="META-INF">
|
||||
<element id="file-copy" path="$PROJECT_DIR$/META-INF/MANIFEST.MF" />
|
||||
</element>
|
||||
</root>
|
||||
</artifact>
|
||||
</component>
|
||||
23
.idea/gradle.xml
generated
Normal file
23
.idea/gradle.xml
generated
Normal file
@ -0,0 +1,23 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="GradleMigrationSettings" migrationVersion="1" />
|
||||
<component name="GradleSettings">
|
||||
<option name="linkedExternalProjectsSettings">
|
||||
<GradleProjectSettings>
|
||||
<option name="externalProjectPath" value="$PROJECT_DIR$" />
|
||||
<option name="gradleHome" value="" />
|
||||
<option name="modules">
|
||||
<set>
|
||||
<option value="$PROJECT_DIR$" />
|
||||
<option value="$PROJECT_DIR$/shine-server-blockchain" />
|
||||
<option value="$PROJECT_DIR$/shine-server-config" />
|
||||
<option value="$PROJECT_DIR$/shine-server-crypto" />
|
||||
<option value="$PROJECT_DIR$/shine-server-db" />
|
||||
<option value="$PROJECT_DIR$/shine-server-net-protocol" />
|
||||
<option value="$PROJECT_DIR$/shine-server-net-server" />
|
||||
</set>
|
||||
</option>
|
||||
</GradleProjectSettings>
|
||||
</option>
|
||||
</component>
|
||||
</project>
|
||||
10
.idea/misc.xml
generated
Normal file
10
.idea/misc.xml
generated
Normal file
@ -0,0 +1,10 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="ExternalStorageConfigurationManager" enabled="true" />
|
||||
<component name="FrameworkDetectionExcludesConfiguration">
|
||||
<file type="web" url="file://$PROJECT_DIR$" />
|
||||
</component>
|
||||
<component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="17 (2)" project-jdk-type="JavaSDK">
|
||||
<output url="file://$PROJECT_DIR$/out" />
|
||||
</component>
|
||||
</project>
|
||||
6
.idea/vcs.xml
generated
Normal file
6
.idea/vcs.xml
generated
Normal file
@ -0,0 +1,6 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="VcsDirectoryMappings">
|
||||
<mapping directory="$PROJECT_DIR$" vcs="Git" />
|
||||
</component>
|
||||
</project>
|
||||
3
META-INF/MANIFEST.MF
Normal file
3
META-INF/MANIFEST.MF
Normal file
@ -0,0 +1,3 @@
|
||||
Manifest-Version: 1.0
|
||||
Main-Class: server.ws.WsServer
|
||||
|
||||
72
build.gradle
Normal file
72
build.gradle
Normal file
@ -0,0 +1,72 @@
|
||||
plugins {
|
||||
id 'java'
|
||||
id 'application'
|
||||
id 'com.github.johnrengelman.shadow' version '8.1.1'
|
||||
}
|
||||
|
||||
group = 'shine'
|
||||
version = '1.0'
|
||||
|
||||
tasks.jar {
|
||||
enabled = false // это что бы не создавала обычный джар, а будет только толстый джар
|
||||
}
|
||||
|
||||
repositories {
|
||||
mavenCentral()
|
||||
}
|
||||
|
||||
dependencies {
|
||||
implementation 'org.eclipse.jetty:jetty-server:11.0.20'
|
||||
implementation 'org.eclipse.jetty:jetty-servlet:11.0.20'
|
||||
implementation 'org.eclipse.jetty.websocket:websocket-jetty-server:11.0.20'
|
||||
implementation 'org.bouncycastle:bcprov-jdk18on:1.78.1' // шифрование
|
||||
implementation 'com.fasterxml.jackson.core:jackson-databind:2.17.1' // json
|
||||
|
||||
implementation 'org.slf4j:slf4j-api:2.0.9'
|
||||
implementation 'ch.qos.logback:logback-classic:1.5.6'
|
||||
|
||||
testImplementation platform('org.junit:junit-bom:5.10.0')
|
||||
testImplementation 'org.junit.jupiter:junit-jupiter'
|
||||
|
||||
|
||||
implementation project(':shine-server-config') // модуль настроек из application.properties
|
||||
implementation project(':shine-server-crypto') // модуль сервера для работы с криптографией
|
||||
implementation project(':shine-server-blockchain') // модуль для работы с блокчейном
|
||||
implementation project(':shine-server-db') // модуль для работы с БД содержит и сущности из БД и саму работу с БД
|
||||
|
||||
implementation project(':shine-server-net-protocol') // Модуль отвечающий за протокол (классы Net..Request/Response
|
||||
implementation project(':shine-server-net-server') // Хэндлеры для обработки сетевых запросов
|
||||
|
||||
|
||||
}
|
||||
|
||||
application {
|
||||
// 👇 класс с методом main
|
||||
mainClass = 'server.ws.WsServer'
|
||||
}
|
||||
|
||||
|
||||
java {
|
||||
toolchain {
|
||||
languageVersion = JavaLanguageVersion.of(17)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
shadowJar {
|
||||
// создаём 1 файл без постфиксов
|
||||
archiveBaseName.set('shine-server')
|
||||
archiveClassifier.set('')
|
||||
archiveVersion.set('')
|
||||
mergeServiceFiles()
|
||||
|
||||
manifest {
|
||||
attributes(
|
||||
'Main-Class': 'server.ws.WsServer'
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
test {
|
||||
useJUnitPlatform()
|
||||
}
|
||||
BIN
gradle/wrapper/gradle-wrapper.jar
vendored
Normal file
BIN
gradle/wrapper/gradle-wrapper.jar
vendored
Normal file
Binary file not shown.
6
gradle/wrapper/gradle-wrapper.properties
vendored
Normal file
6
gradle/wrapper/gradle-wrapper.properties
vendored
Normal file
@ -0,0 +1,6 @@
|
||||
#Mon Oct 20 16:15:09 MSK 2025
|
||||
distributionBase=GRADLE_USER_HOME
|
||||
distributionPath=wrapper/dists
|
||||
distributionUrl=https\://services.gradle.org/distributions/gradle-8.14-bin.zip
|
||||
zipStoreBase=GRADLE_USER_HOME
|
||||
zipStorePath=wrapper/dists
|
||||
234
gradlew
vendored
Executable file
234
gradlew
vendored
Executable file
@ -0,0 +1,234 @@
|
||||
#!/bin/sh
|
||||
|
||||
#
|
||||
# Copyright © 2015-2021 the original authors.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# https://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
#
|
||||
|
||||
##############################################################################
|
||||
#
|
||||
# Gradle start up script for POSIX generated by Gradle.
|
||||
#
|
||||
# Important for running:
|
||||
#
|
||||
# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
|
||||
# noncompliant, but you have some other compliant shell such as ksh or
|
||||
# bash, then to run this script, type that shell name before the whole
|
||||
# command line, like:
|
||||
#
|
||||
# ksh Gradle
|
||||
#
|
||||
# Busybox and similar reduced shells will NOT work, because this script
|
||||
# requires all of these POSIX shell features:
|
||||
# * functions;
|
||||
# * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
|
||||
# «${var#prefix}», «${var%suffix}», and «$( cmd )»;
|
||||
# * compound commands having a testable exit status, especially «case»;
|
||||
# * various built-in commands including «command», «set», and «ulimit».
|
||||
#
|
||||
# Important for patching:
|
||||
#
|
||||
# (2) This script targets any POSIX shell, so it avoids extensions provided
|
||||
# by Bash, Ksh, etc; in particular arrays are avoided.
|
||||
#
|
||||
# The "traditional" practice of packing multiple parameters into a
|
||||
# space-separated string is a well documented source of bugs and security
|
||||
# problems, so this is (mostly) avoided, by progressively accumulating
|
||||
# options in "$@", and eventually passing that to Java.
|
||||
#
|
||||
# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
|
||||
# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
|
||||
# see the in-line comments for details.
|
||||
#
|
||||
# There are tweaks for specific operating systems such as AIX, CygWin,
|
||||
# Darwin, MinGW, and NonStop.
|
||||
#
|
||||
# (3) This script is generated from the Groovy template
|
||||
# https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
|
||||
# within the Gradle project.
|
||||
#
|
||||
# You can find Gradle at https://github.com/gradle/gradle/.
|
||||
#
|
||||
##############################################################################
|
||||
|
||||
# Attempt to set APP_HOME
|
||||
|
||||
# Resolve links: $0 may be a link
|
||||
app_path=$0
|
||||
|
||||
# Need this for daisy-chained symlinks.
|
||||
while
|
||||
APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path
|
||||
[ -h "$app_path" ]
|
||||
do
|
||||
ls=$( ls -ld "$app_path" )
|
||||
link=${ls#*' -> '}
|
||||
case $link in #(
|
||||
/*) app_path=$link ;; #(
|
||||
*) app_path=$APP_HOME$link ;;
|
||||
esac
|
||||
done
|
||||
|
||||
APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
|
||||
|
||||
APP_NAME="Gradle"
|
||||
APP_BASE_NAME=${0##*/}
|
||||
|
||||
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
|
||||
DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
|
||||
|
||||
# Use the maximum available, or set MAX_FD != -1 to use that value.
|
||||
MAX_FD=maximum
|
||||
|
||||
warn () {
|
||||
echo "$*"
|
||||
} >&2
|
||||
|
||||
die () {
|
||||
echo
|
||||
echo "$*"
|
||||
echo
|
||||
exit 1
|
||||
} >&2
|
||||
|
||||
# OS specific support (must be 'true' or 'false').
|
||||
cygwin=false
|
||||
msys=false
|
||||
darwin=false
|
||||
nonstop=false
|
||||
case "$( uname )" in #(
|
||||
CYGWIN* ) cygwin=true ;; #(
|
||||
Darwin* ) darwin=true ;; #(
|
||||
MSYS* | MINGW* ) msys=true ;; #(
|
||||
NONSTOP* ) nonstop=true ;;
|
||||
esac
|
||||
|
||||
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
|
||||
|
||||
|
||||
# Determine the Java command to use to start the JVM.
|
||||
if [ -n "$JAVA_HOME" ] ; then
|
||||
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
|
||||
# IBM's JDK on AIX uses strange locations for the executables
|
||||
JAVACMD=$JAVA_HOME/jre/sh/java
|
||||
else
|
||||
JAVACMD=$JAVA_HOME/bin/java
|
||||
fi
|
||||
if [ ! -x "$JAVACMD" ] ; then
|
||||
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
|
||||
|
||||
Please set the JAVA_HOME variable in your environment to match the
|
||||
location of your Java installation."
|
||||
fi
|
||||
else
|
||||
JAVACMD=java
|
||||
which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
|
||||
|
||||
Please set the JAVA_HOME variable in your environment to match the
|
||||
location of your Java installation."
|
||||
fi
|
||||
|
||||
# Increase the maximum file descriptors if we can.
|
||||
if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
|
||||
case $MAX_FD in #(
|
||||
max*)
|
||||
MAX_FD=$( ulimit -H -n ) ||
|
||||
warn "Could not query maximum file descriptor limit"
|
||||
esac
|
||||
case $MAX_FD in #(
|
||||
'' | soft) :;; #(
|
||||
*)
|
||||
ulimit -n "$MAX_FD" ||
|
||||
warn "Could not set maximum file descriptor limit to $MAX_FD"
|
||||
esac
|
||||
fi
|
||||
|
||||
# Collect all arguments for the java command, stacking in reverse order:
|
||||
# * args from the command line
|
||||
# * the main class name
|
||||
# * -classpath
|
||||
# * -D...appname settings
|
||||
# * --module-path (only if needed)
|
||||
# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
|
||||
|
||||
# For Cygwin or MSYS, switch paths to Windows format before running java
|
||||
if "$cygwin" || "$msys" ; then
|
||||
APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
|
||||
CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
|
||||
|
||||
JAVACMD=$( cygpath --unix "$JAVACMD" )
|
||||
|
||||
# Now convert the arguments - kludge to limit ourselves to /bin/sh
|
||||
for arg do
|
||||
if
|
||||
case $arg in #(
|
||||
-*) false ;; # don't mess with options #(
|
||||
/?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath
|
||||
[ -e "$t" ] ;; #(
|
||||
*) false ;;
|
||||
esac
|
||||
then
|
||||
arg=$( cygpath --path --ignore --mixed "$arg" )
|
||||
fi
|
||||
# Roll the args list around exactly as many times as the number of
|
||||
# args, so each arg winds up back in the position where it started, but
|
||||
# possibly modified.
|
||||
#
|
||||
# NB: a `for` loop captures its iteration list before it begins, so
|
||||
# changing the positional parameters here affects neither the number of
|
||||
# iterations, nor the values presented in `arg`.
|
||||
shift # remove old arg
|
||||
set -- "$@" "$arg" # push replacement arg
|
||||
done
|
||||
fi
|
||||
|
||||
# Collect all arguments for the java command;
|
||||
# * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
|
||||
# shell script including quotes and variable substitutions, so put them in
|
||||
# double quotes to make sure that they get re-expanded; and
|
||||
# * put everything else in single quotes, so that it's not re-expanded.
|
||||
|
||||
set -- \
|
||||
"-Dorg.gradle.appname=$APP_BASE_NAME" \
|
||||
-classpath "$CLASSPATH" \
|
||||
org.gradle.wrapper.GradleWrapperMain \
|
||||
"$@"
|
||||
|
||||
# Use "xargs" to parse quoted args.
|
||||
#
|
||||
# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
|
||||
#
|
||||
# In Bash we could simply go:
|
||||
#
|
||||
# readarray ARGS < <( xargs -n1 <<<"$var" ) &&
|
||||
# set -- "${ARGS[@]}" "$@"
|
||||
#
|
||||
# but POSIX shell has neither arrays nor command substitution, so instead we
|
||||
# post-process each arg (as a line of input to sed) to backslash-escape any
|
||||
# character that might be a shell metacharacter, then use eval to reverse
|
||||
# that process (while maintaining the separation between arguments), and wrap
|
||||
# the whole thing up as a single "set" statement.
|
||||
#
|
||||
# This will of course break if any of these variables contains a newline or
|
||||
# an unmatched quote.
|
||||
#
|
||||
|
||||
eval "set -- $(
|
||||
printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
|
||||
xargs -n1 |
|
||||
sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
|
||||
tr '\n' ' '
|
||||
)" '"$@"'
|
||||
|
||||
exec "$JAVACMD" "$@"
|
||||
89
gradlew.bat
vendored
Normal file
89
gradlew.bat
vendored
Normal file
@ -0,0 +1,89 @@
|
||||
@rem
|
||||
@rem Copyright 2015 the original author or authors.
|
||||
@rem
|
||||
@rem Licensed under the Apache License, Version 2.0 (the "License");
|
||||
@rem you may not use this file except in compliance with the License.
|
||||
@rem You may obtain a copy of the License at
|
||||
@rem
|
||||
@rem https://www.apache.org/licenses/LICENSE-2.0
|
||||
@rem
|
||||
@rem Unless required by applicable law or agreed to in writing, software
|
||||
@rem distributed under the License is distributed on an "AS IS" BASIS,
|
||||
@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
@rem See the License for the specific language governing permissions and
|
||||
@rem limitations under the License.
|
||||
@rem
|
||||
|
||||
@if "%DEBUG%" == "" @echo off
|
||||
@rem ##########################################################################
|
||||
@rem
|
||||
@rem Gradle startup script for Windows
|
||||
@rem
|
||||
@rem ##########################################################################
|
||||
|
||||
@rem Set local scope for the variables with windows NT shell
|
||||
if "%OS%"=="Windows_NT" setlocal
|
||||
|
||||
set DIRNAME=%~dp0
|
||||
if "%DIRNAME%" == "" set DIRNAME=.
|
||||
set APP_BASE_NAME=%~n0
|
||||
set APP_HOME=%DIRNAME%
|
||||
|
||||
@rem Resolve any "." and ".." in APP_HOME to make it shorter.
|
||||
for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
|
||||
|
||||
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
|
||||
set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
|
||||
|
||||
@rem Find java.exe
|
||||
if defined JAVA_HOME goto findJavaFromJavaHome
|
||||
|
||||
set JAVA_EXE=java.exe
|
||||
%JAVA_EXE% -version >NUL 2>&1
|
||||
if "%ERRORLEVEL%" == "0" goto execute
|
||||
|
||||
echo.
|
||||
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
|
||||
echo.
|
||||
echo Please set the JAVA_HOME variable in your environment to match the
|
||||
echo location of your Java installation.
|
||||
|
||||
goto fail
|
||||
|
||||
:findJavaFromJavaHome
|
||||
set JAVA_HOME=%JAVA_HOME:"=%
|
||||
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
|
||||
|
||||
if exist "%JAVA_EXE%" goto execute
|
||||
|
||||
echo.
|
||||
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
|
||||
echo.
|
||||
echo Please set the JAVA_HOME variable in your environment to match the
|
||||
echo location of your Java installation.
|
||||
|
||||
goto fail
|
||||
|
||||
:execute
|
||||
@rem Setup the command line
|
||||
|
||||
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
|
||||
|
||||
|
||||
@rem Execute Gradle
|
||||
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
|
||||
|
||||
:end
|
||||
@rem End local scope for the variables with windows NT shell
|
||||
if "%ERRORLEVEL%"=="0" goto mainEnd
|
||||
|
||||
:fail
|
||||
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
|
||||
rem the _cmd.exe /c_ return code!
|
||||
if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
|
||||
exit /b 1
|
||||
|
||||
:mainEnd
|
||||
if "%OS%"=="Windows_NT" endlocal
|
||||
|
||||
:omega
|
||||
8
settings.gradle
Normal file
8
settings.gradle
Normal file
@ -0,0 +1,8 @@
|
||||
rootProject.name = 'shine-server-server'
|
||||
|
||||
include 'shine-server-config'
|
||||
include 'shine-server-crypto'
|
||||
include 'shine-server-blockchain'
|
||||
include 'shine-server-db'
|
||||
include 'shine-server-net-protocol'
|
||||
include 'shine-server-net-server'
|
||||
33
shine-server-blockchain/build.gradle
Normal file
33
shine-server-blockchain/build.gradle
Normal file
@ -0,0 +1,33 @@
|
||||
plugins {
|
||||
id 'java'
|
||||
}
|
||||
|
||||
group = 'shine'
|
||||
version = '1.0.0'
|
||||
|
||||
java {
|
||||
toolchain {
|
||||
languageVersion = JavaLanguageVersion.of(17)
|
||||
}
|
||||
}
|
||||
|
||||
repositories {
|
||||
mavenCentral()
|
||||
}
|
||||
|
||||
dependencies {
|
||||
// модуль блокчейна использует крипту
|
||||
implementation project(':shine-server-crypto')
|
||||
|
||||
// JSON (BchInfoManager)
|
||||
implementation 'com.fasterxml.jackson.core:jackson-databind:2.18.1'
|
||||
|
||||
// логгер
|
||||
implementation 'org.slf4j:slf4j-api:2.0.16'
|
||||
|
||||
testImplementation 'org.junit.jupiter:junit-jupiter:5.11.0'
|
||||
}
|
||||
|
||||
test {
|
||||
useJUnitPlatform()
|
||||
}
|
||||
25
shine-server-config/build.gradle
Normal file
25
shine-server-config/build.gradle
Normal file
@ -0,0 +1,25 @@
|
||||
plugins {
|
||||
id 'java'
|
||||
}
|
||||
|
||||
group = 'shine'
|
||||
version = '1.0.0'
|
||||
|
||||
repositories {
|
||||
mavenCentral()
|
||||
}
|
||||
|
||||
java {
|
||||
toolchain {
|
||||
languageVersion = JavaLanguageVersion.of(17)
|
||||
}
|
||||
}
|
||||
|
||||
dependencies {
|
||||
// обычно тут пусто, максимум логгер и тесты
|
||||
testImplementation 'org.junit.jupiter:junit-jupiter:5.11.0'
|
||||
}
|
||||
|
||||
test {
|
||||
useJUnitPlatform()
|
||||
}
|
||||
@ -0,0 +1,58 @@
|
||||
package utils.config;
|
||||
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.util.Properties;
|
||||
|
||||
public final class AppConfig {
|
||||
|
||||
private static volatile AppConfig instance;
|
||||
private final Properties properties = new Properties();
|
||||
|
||||
private AppConfig() {
|
||||
load();
|
||||
}
|
||||
|
||||
public static AppConfig getInstance() {
|
||||
if (instance == null) {
|
||||
synchronized (AppConfig.class) {
|
||||
if (instance == null) {
|
||||
instance = new AppConfig();
|
||||
}
|
||||
}
|
||||
}
|
||||
return instance;
|
||||
}
|
||||
|
||||
private void load() {
|
||||
try (InputStream in = getClass().getClassLoader()
|
||||
.getResourceAsStream("application.properties")) {
|
||||
|
||||
if (in == null) {
|
||||
throw new RuntimeException("Config file application.properties not found");
|
||||
}
|
||||
|
||||
properties.load(in);
|
||||
|
||||
} catch (IOException e) {
|
||||
throw new RuntimeException("Failed to load application.properties", e);
|
||||
}
|
||||
}
|
||||
|
||||
/** Вернёт значение строки или null, если параметр не найден */
|
||||
public String getParam(String name) {
|
||||
return properties.getProperty(name);
|
||||
}
|
||||
|
||||
/** Можно добавить методы для удобства */
|
||||
public int getInt(String name, int defaultValue) {
|
||||
String v = properties.getProperty(name);
|
||||
return v == null ? defaultValue : Integer.parseInt(v);
|
||||
}
|
||||
|
||||
public boolean getBoolean(String name, boolean defaultValue) {
|
||||
String v = properties.getProperty(name);
|
||||
return v == null ? defaultValue : Boolean.parseBoolean(v);
|
||||
}
|
||||
}
|
||||
26
shine-server-db/build.gradle
Normal file
26
shine-server-db/build.gradle
Normal file
@ -0,0 +1,26 @@
|
||||
plugins {
|
||||
id 'java'
|
||||
}
|
||||
|
||||
group = 'shine'
|
||||
version = '1.0.0'
|
||||
|
||||
java {
|
||||
toolchain {
|
||||
languageVersion = JavaLanguageVersion.of(17)
|
||||
}
|
||||
}
|
||||
|
||||
repositories {
|
||||
mavenCentral()
|
||||
}
|
||||
|
||||
dependencies {
|
||||
implementation 'org.xerial:sqlite-jdbc:3.47.0.0'
|
||||
implementation project(':shine-server-config') // модуль с настройками
|
||||
}
|
||||
|
||||
java {
|
||||
sourceCompatibility = JavaVersion.VERSION_17
|
||||
targetCompatibility = JavaVersion.VERSION_17
|
||||
}
|
||||
16
shine-server-db/concat_to_file.sh
Executable file
16
shine-server-db/concat_to_file.sh
Executable file
@ -0,0 +1,16 @@
|
||||
#!/usr/bin/env bash
|
||||
set -euo pipefail
|
||||
|
||||
OUTFILE="all_files.txt"
|
||||
|
||||
# очищаем или создаём файл
|
||||
: > "$OUTFILE"
|
||||
|
||||
# собрать только *.java файлы и вывести их содержимое в файл
|
||||
find . -type f -name "*.java" | sort | while read -r f; do
|
||||
cat "$f" >> "$OUTFILE"
|
||||
echo >> "$OUTFILE" # пустая строка-разделитель
|
||||
done
|
||||
|
||||
echo "Готово! Все .java файлы собраны в $OUTFILE"
|
||||
|
||||
126
shine-server-db/src/main/java/shine/db/DatabaseInitializer.java
Normal file
126
shine-server-db/src/main/java/shine/db/DatabaseInitializer.java
Normal file
@ -0,0 +1,126 @@
|
||||
package shine.db;
|
||||
|
||||
|
||||
import utils.config.AppConfig;
|
||||
|
||||
import java.io.BufferedReader;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStreamReader;
|
||||
import java.nio.file.*;
|
||||
import java.sql.Connection;
|
||||
import java.sql.DriverManager;
|
||||
import java.sql.SQLException;
|
||||
import java.sql.Statement;
|
||||
|
||||
public class DatabaseInitializer {
|
||||
|
||||
public static void createNewDB(String[] args) {
|
||||
AppConfig config = AppConfig.getInstance();
|
||||
String dbPath = config.getParam("db.path");
|
||||
|
||||
if (dbPath == null || dbPath.isBlank()) {
|
||||
System.err.println("Параметр db.path не задан в application.properties");
|
||||
return;
|
||||
}
|
||||
|
||||
Path dbFile = Paths.get(dbPath);
|
||||
try {
|
||||
// создаём директорию, если нужно
|
||||
Path parent = dbFile.getParent();
|
||||
if (parent != null && !Files.exists(parent)) {
|
||||
Files.createDirectories(parent);
|
||||
}
|
||||
|
||||
if (Files.exists(dbFile)) {
|
||||
System.out.println("Файл базы данных уже существует: " + dbFile.toAbsolutePath());
|
||||
System.out.print("Пересоздать БД (СТАРАЯ БУДЕТ УДАЛЕНА)? [y/N]: ");
|
||||
|
||||
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
|
||||
String answer = reader.readLine();
|
||||
if (!"y".equalsIgnoreCase(answer) && !"yes".equalsIgnoreCase(answer)) {
|
||||
System.out.println("Операция отменена. БД не изменена.");
|
||||
return;
|
||||
}
|
||||
|
||||
Files.delete(dbFile);
|
||||
System.out.println("Старый файл БД удалён.");
|
||||
}
|
||||
|
||||
createSchema("jdbc:sqlite:" + dbPath);
|
||||
System.out.println("Новая БД успешно создана по пути: " + dbFile.toAbsolutePath());
|
||||
|
||||
} catch (IOException e) {
|
||||
System.err.println("Ошибка работы с файлом БД: " + e.getMessage());
|
||||
} catch (SQLException e) {
|
||||
System.err.println("Ошибка создания схемы БД: " + e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
private static void createSchema(String jdbcUrl) throws SQLException {
|
||||
try {
|
||||
Class.forName("org.sqlite.JDBC");
|
||||
} catch (ClassNotFoundException e) {
|
||||
throw new RuntimeException("SQLite JDBC driver not found", e);
|
||||
}
|
||||
|
||||
try (Connection conn = DriverManager.getConnection(jdbcUrl);
|
||||
Statement st = conn.createStatement()) {
|
||||
|
||||
// включаем внешние ключи на этом соединении (для инициализации тоже)
|
||||
st.execute("PRAGMA foreign_keys = ON");
|
||||
|
||||
// 1. Таблица solana_users
|
||||
st.executeUpdate("""
|
||||
CREATE TABLE IF NOT EXISTS solana_users (
|
||||
login TEXT NOT NULL,
|
||||
loginId INTEGER NOT NULL PRIMARY KEY,
|
||||
bchId INTEGER NOT NULL,
|
||||
pubkey0 TEXT,
|
||||
pubkey1 TEXT,
|
||||
bchLimit INTEGER -- может быть NULL
|
||||
);
|
||||
""");
|
||||
|
||||
st.executeUpdate("""
|
||||
CREATE INDEX IF NOT EXISTS idx_solana_users_login
|
||||
ON solana_users (login);
|
||||
""");
|
||||
|
||||
// 2. Таблица active_sessions
|
||||
st.executeUpdate("""
|
||||
CREATE TABLE IF NOT EXISTS active_sessions (
|
||||
sessionId INTEGER NOT NULL PRIMARY KEY,
|
||||
session_pwd TEXT NOT NULL,
|
||||
loginId INTEGER NOT NULL,
|
||||
time_ms INTEGER NOT NULL,
|
||||
pubkey_num INTEGER NOT NULL,
|
||||
push_endpoint TEXT,
|
||||
push_p256dh_key TEXT,
|
||||
push_auth_key TEXT,
|
||||
FOREIGN KEY (loginId) REFERENCES solana_users(loginId)
|
||||
);
|
||||
""");
|
||||
|
||||
// 3. Таблица users_params
|
||||
// Важно: пара (loginId, param) должна быть уникальна
|
||||
st.executeUpdate("""
|
||||
CREATE TABLE IF NOT EXISTS users_params (
|
||||
loginId INTEGER NOT NULL,
|
||||
param TEXT NOT NULL,
|
||||
bch_channel_id INTEGER NOT NULL DEFAULT 0,
|
||||
value TEXT,
|
||||
time_ms INTEGER NOT NULL,
|
||||
pubkey_num INTEGER NOT NULL,
|
||||
signature TEXT,
|
||||
FOREIGN KEY (loginId) REFERENCES solana_users(loginId),
|
||||
UNIQUE (loginId, param)
|
||||
);
|
||||
""");
|
||||
|
||||
st.executeUpdate("""
|
||||
CREATE INDEX IF NOT EXISTS idx_users_params_loginId
|
||||
ON users_params (loginId);
|
||||
""");
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,82 @@
|
||||
package shine.db;
|
||||
|
||||
import shine.db.dao.ActiveSessionsDAO;
|
||||
import utils.config.AppConfig;
|
||||
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.nio.file.Paths;
|
||||
import java.sql.Connection;
|
||||
import java.sql.DriverManager;
|
||||
import java.sql.SQLException;
|
||||
import java.sql.Statement;
|
||||
|
||||
public final class SqliteDbController {
|
||||
|
||||
private static volatile SqliteDbController instance;
|
||||
private final Connection connection;
|
||||
|
||||
private SqliteDbController() {
|
||||
try {
|
||||
// Подгружаем драйвер SQLite
|
||||
Class.forName("org.sqlite.JDBC");
|
||||
} catch (ClassNotFoundException e) {
|
||||
throw new RuntimeException("SQLite JDBC driver not found", e);
|
||||
}
|
||||
|
||||
String dbPath = AppConfig.getInstance().getParam("db.path");
|
||||
|
||||
if (dbPath == null || dbPath.isBlank()) {
|
||||
throw new RuntimeException("Config param 'db.path' is not set in application.properties");
|
||||
}
|
||||
|
||||
Path dbFile = Paths.get(dbPath);
|
||||
|
||||
// 👉 Если файла БД нет — создаём новую БД через DatabaseInitializer
|
||||
if (!Files.exists(dbFile)) {
|
||||
System.out.println("[DB] Файл БД не найден: " + dbFile.toAbsolutePath());
|
||||
System.out.println("[DB] Создаём новую БД с помощью DatabaseInitializer...");
|
||||
|
||||
// можно передать пустой массив аргументов
|
||||
DatabaseInitializer.createNewDB(new String[0]);
|
||||
}
|
||||
|
||||
String url = "jdbc:sqlite:" + dbPath;
|
||||
|
||||
try {
|
||||
this.connection = DriverManager.getConnection(url);
|
||||
this.connection.setAutoCommit(true);
|
||||
|
||||
// ВАЖНО: включаем поддержку внешних ключей для этого соединения
|
||||
try (Statement st = this.connection.createStatement()) {
|
||||
st.execute("PRAGMA foreign_keys = ON");
|
||||
}
|
||||
|
||||
} catch (SQLException e) {
|
||||
throw new RuntimeException("Failed to connect to SQLite database: " + url, e);
|
||||
}
|
||||
}
|
||||
|
||||
public static SqliteDbController getInstance() {
|
||||
if (instance == null) {
|
||||
synchronized (SqliteDbController.class) {
|
||||
if (instance == null) {
|
||||
instance = new SqliteDbController();
|
||||
}
|
||||
}
|
||||
}
|
||||
return instance;
|
||||
}
|
||||
|
||||
public Connection getConnection() {
|
||||
return connection;
|
||||
}
|
||||
|
||||
public void close() {
|
||||
try {
|
||||
connection.close();
|
||||
} catch (SQLException e) {
|
||||
// логировать по необходимости
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,116 @@
|
||||
package shine.db.dao;
|
||||
|
||||
import shine.db.SqliteDbController;
|
||||
import shine.db.entities.ActiveSession;
|
||||
|
||||
import java.sql.*;
|
||||
|
||||
/** Здесь мы хрним данные об активных сессиях пользователя (для wss соединений) */
|
||||
|
||||
public final class ActiveSessionsDAO {
|
||||
|
||||
private static volatile ActiveSessionsDAO instance;
|
||||
private final SqliteDbController db = SqliteDbController.getInstance();
|
||||
|
||||
private ActiveSessionsDAO() {
|
||||
}
|
||||
|
||||
public static ActiveSessionsDAO getInstance() {
|
||||
if (instance == null) {
|
||||
synchronized (ActiveSessionsDAO.class) {
|
||||
if (instance == null) {
|
||||
instance = new ActiveSessionsDAO();
|
||||
}
|
||||
}
|
||||
}
|
||||
return instance;
|
||||
}
|
||||
|
||||
public void insert(ActiveSession session) throws SQLException {
|
||||
String sql = """
|
||||
INSERT INTO active_sessions (
|
||||
sessionId,
|
||||
session_pwd,
|
||||
loginId,
|
||||
time_ms,
|
||||
pubkey_num,
|
||||
push_endpoint,
|
||||
push_p256dh_key,
|
||||
push_auth_key
|
||||
) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
|
||||
""";
|
||||
|
||||
try (PreparedStatement ps = db.getConnection().prepareStatement(sql)) {
|
||||
ps.setLong(1, session.getSessionId());
|
||||
ps.setString(2, session.getSessionPwd());
|
||||
ps.setLong(3, session.getLoginId());
|
||||
ps.setLong(4, session.getTimeMs());
|
||||
ps.setInt(5, session.getPubkeyNum());
|
||||
ps.setString(6, session.getPushEndpoint());
|
||||
ps.setString(7, session.getPushP256dhKey());
|
||||
ps.setString(8, session.getPushAuthKey());
|
||||
ps.executeUpdate();
|
||||
}
|
||||
}
|
||||
|
||||
public ActiveSession getBySessionId(long sessionId) throws SQLException {
|
||||
String sql = """
|
||||
SELECT
|
||||
sessionId,
|
||||
session_pwd,
|
||||
loginId,
|
||||
time_ms,
|
||||
pubkey_num,
|
||||
push_endpoint,
|
||||
push_p256dh_key,
|
||||
push_auth_key
|
||||
FROM active_sessions
|
||||
WHERE sessionId = ?
|
||||
""";
|
||||
|
||||
try (PreparedStatement ps = db.getConnection().prepareStatement(sql)) {
|
||||
ps.setLong(1, sessionId);
|
||||
try (ResultSet rs = ps.executeQuery()) {
|
||||
if (!rs.next()) {
|
||||
return null;
|
||||
}
|
||||
return mapRow(rs);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Удаление записи по sessionId.
|
||||
* Если записи нет — просто ничего не удалит (0 строк).
|
||||
*/
|
||||
public void deleteBySessionId(long sessionId) throws SQLException {
|
||||
String sql = "DELETE FROM active_sessions WHERE sessionId = ?";
|
||||
|
||||
try (PreparedStatement ps = db.getConnection().prepareStatement(sql)) {
|
||||
ps.setLong(1, sessionId);
|
||||
ps.executeUpdate();
|
||||
}
|
||||
}
|
||||
|
||||
private ActiveSession mapRow(ResultSet rs) throws SQLException {
|
||||
long sessionId = rs.getLong("sessionId");
|
||||
String sessionPwd = rs.getString("session_pwd");
|
||||
long loginId = rs.getLong("loginId");
|
||||
long timeMs = rs.getLong("time_ms");
|
||||
short pubkeyNum = (short) rs.getInt("pubkey_num");
|
||||
String pushEndpoint = rs.getString("push_endpoint");
|
||||
String pushP256dhKey = rs.getString("push_p256dh_key");
|
||||
String pushAuthKey = rs.getString("push_auth_key");
|
||||
|
||||
return new ActiveSession(
|
||||
sessionId,
|
||||
sessionPwd,
|
||||
loginId,
|
||||
timeMs,
|
||||
pubkeyNum,
|
||||
pushEndpoint,
|
||||
pushP256dhKey,
|
||||
pushAuthKey
|
||||
);
|
||||
}
|
||||
}
|
||||
119
shine-server-db/src/main/java/shine/db/dao/SolanaUsersDAO.java
Normal file
119
shine-server-db/src/main/java/shine/db/dao/SolanaUsersDAO.java
Normal file
@ -0,0 +1,119 @@
|
||||
package shine.db.dao;
|
||||
|
||||
import shine.db.SqliteDbController;
|
||||
import shine.db.entities.SolanaUser;
|
||||
|
||||
import java.sql.*;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/** Здесь храним данные об пользователях - локальная копия того что есть в солане */
|
||||
|
||||
public final class SolanaUsersDAO {
|
||||
|
||||
private static volatile SolanaUsersDAO instance;
|
||||
private final SqliteDbController db = SqliteDbController.getInstance();
|
||||
|
||||
private SolanaUsersDAO() {}
|
||||
|
||||
public static SolanaUsersDAO getInstance() {
|
||||
if (instance == null) {
|
||||
synchronized (SolanaUsersDAO.class) {
|
||||
if (instance == null) {
|
||||
instance = new SolanaUsersDAO();
|
||||
}
|
||||
}
|
||||
}
|
||||
return instance;
|
||||
}
|
||||
|
||||
public void insert(SolanaUser user) throws SQLException {
|
||||
String sql = """
|
||||
INSERT INTO solana_users (login, loginId, bchId, pubkey0, pubkey1, bchLimit)
|
||||
VALUES (?, ?, ?, ?, ?, ?)
|
||||
""";
|
||||
|
||||
try (PreparedStatement ps = db.getConnection().prepareStatement(sql)) {
|
||||
ps.setString(1, user.getLogin());
|
||||
ps.setLong(2, user.getLoginId());
|
||||
ps.setLong(3, user.getBchId());
|
||||
ps.setString(4, user.getPubkey0());
|
||||
ps.setString(5, user.getPubkey1());
|
||||
|
||||
if (user.getBchLimit() != null) {
|
||||
ps.setInt(6, user.getBchLimit());
|
||||
} else {
|
||||
ps.setNull(6, Types.INTEGER);
|
||||
}
|
||||
|
||||
ps.executeUpdate();
|
||||
}
|
||||
}
|
||||
|
||||
public SolanaUser getByLoginId(long loginId) throws SQLException {
|
||||
String sql = """
|
||||
SELECT login, loginId, bchId, pubkey0, pubkey1, bchLimit
|
||||
FROM solana_users
|
||||
WHERE loginId = ?
|
||||
""";
|
||||
|
||||
try (PreparedStatement ps = db.getConnection().prepareStatement(sql)) {
|
||||
ps.setLong(1, loginId);
|
||||
|
||||
try (ResultSet rs = ps.executeQuery()) {
|
||||
if (!rs.next()) return null;
|
||||
return mapRow(rs);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public SolanaUser getByLogin(String login) throws SQLException {
|
||||
String sql = """
|
||||
SELECT login, loginId, bchId, pubkey0, pubkey1, bchLimit
|
||||
FROM solana_users
|
||||
WHERE LOWER(login) = LOWER(?)
|
||||
""";
|
||||
|
||||
try (PreparedStatement ps = db.getConnection().prepareStatement(sql)) {
|
||||
ps.setString(1, login);
|
||||
|
||||
try (ResultSet rs = ps.executeQuery()) {
|
||||
if (!rs.next()) return null;
|
||||
return mapRow(rs);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public List<SolanaUser> searchByLoginPrefix(String prefix) throws SQLException {
|
||||
String sql = """
|
||||
SELECT login, loginId, bchId, pubkey0, pubkey1, bchLimit
|
||||
FROM solana_users
|
||||
WHERE LOWER(login) LIKE ?
|
||||
ORDER BY login
|
||||
LIMIT 5
|
||||
""";
|
||||
|
||||
List<SolanaUser> result = new ArrayList<>();
|
||||
|
||||
try (PreparedStatement ps = db.getConnection().prepareStatement(sql)) {
|
||||
ps.setString(1, prefix.toLowerCase() + "%");
|
||||
|
||||
try (ResultSet rs = ps.executeQuery()) {
|
||||
while (rs.next()) result.add(mapRow(rs));
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private SolanaUser mapRow(ResultSet rs) throws SQLException {
|
||||
return new SolanaUser(
|
||||
rs.getLong("loginId"),
|
||||
rs.getString("login"),
|
||||
rs.getLong("bchId"),
|
||||
rs.getString("pubkey0"),
|
||||
rs.getString("pubkey1"),
|
||||
rs.getObject("bchLimit") != null ? rs.getInt("bchLimit") : null
|
||||
);
|
||||
}
|
||||
}
|
||||
136
shine-server-db/src/main/java/shine/db/dao/UserParamsDAO.java
Normal file
136
shine-server-db/src/main/java/shine/db/dao/UserParamsDAO.java
Normal file
@ -0,0 +1,136 @@
|
||||
package shine.db.dao;
|
||||
|
||||
import shine.db.SqliteDbController;
|
||||
import shine.db.entities.UserParam;
|
||||
|
||||
import java.sql.*;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/** Здесь зраним сохранённые параметры пользователей (в основном до каково сообщения просмотрены ленты) */
|
||||
|
||||
public final class UserParamsDAO {
|
||||
|
||||
private static volatile UserParamsDAO instance;
|
||||
private final SqliteDbController db = SqliteDbController.getInstance();
|
||||
|
||||
private UserParamsDAO() {
|
||||
}
|
||||
|
||||
public static UserParamsDAO getInstance() {
|
||||
if (instance == null) {
|
||||
synchronized (UserParamsDAO.class) {
|
||||
if (instance == null) {
|
||||
instance = new UserParamsDAO();
|
||||
}
|
||||
}
|
||||
}
|
||||
return instance;
|
||||
}
|
||||
|
||||
/**
|
||||
* UPSERT методом ON CONFLICT — одним SQL-запросом.
|
||||
* Если запись существует -> обновляем поля.
|
||||
* Если нет -> вставляем новую запись.
|
||||
*/
|
||||
public void upsert(UserParam param) throws SQLException {
|
||||
String sql = """
|
||||
INSERT INTO users_params (
|
||||
loginId,
|
||||
param,
|
||||
bch_channel_id,
|
||||
value,
|
||||
time_ms,
|
||||
pubkey_num,
|
||||
signature
|
||||
) VALUES (?, ?, ?, ?, ?, ?, ?)
|
||||
ON CONFLICT(loginId, param)
|
||||
DO UPDATE SET
|
||||
bch_channel_id = excluded.bch_channel_id,
|
||||
value = excluded.value,
|
||||
time_ms = excluded.time_ms,
|
||||
pubkey_num = excluded.pubkey_num,
|
||||
signature = excluded.signature
|
||||
""";
|
||||
|
||||
try (PreparedStatement ps = db.getConnection().prepareStatement(sql)) {
|
||||
ps.setLong(1, param.getLoginId());
|
||||
ps.setString(2, param.getParam());
|
||||
ps.setLong(3, param.getBchChannelId());
|
||||
ps.setString(4, param.getValue());
|
||||
ps.setLong(5, param.getTimeMs());
|
||||
ps.setInt(6, param.getPubkeyNum());
|
||||
ps.setString(7, param.getSignature());
|
||||
ps.executeUpdate();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Получить параметр по loginId + param.
|
||||
*/
|
||||
public UserParam getByUserIdAndParam(long loginId, String paramName) throws SQLException {
|
||||
String sql = """
|
||||
SELECT
|
||||
loginId,
|
||||
param,
|
||||
bch_channel_id,
|
||||
value,
|
||||
time_ms,
|
||||
pubkey_num,
|
||||
signature
|
||||
FROM users_params
|
||||
WHERE loginId = ? AND param = ?
|
||||
""";
|
||||
|
||||
try (PreparedStatement ps = db.getConnection().prepareStatement(sql)) {
|
||||
ps.setLong(1, loginId);
|
||||
ps.setString(2, paramName);
|
||||
try (ResultSet rs = ps.executeQuery()) {
|
||||
if (!rs.next()) return null;
|
||||
return mapRow(rs);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Получить все параметры пользователя.
|
||||
*/
|
||||
public List<UserParam> getByUserId(long loginId) throws SQLException {
|
||||
String sql = """
|
||||
SELECT
|
||||
loginId,
|
||||
param,
|
||||
bch_channel_id,
|
||||
value,
|
||||
time_ms,
|
||||
pubkey_num,
|
||||
signature
|
||||
FROM users_params
|
||||
WHERE loginId = ?
|
||||
ORDER BY time_ms DESC
|
||||
""";
|
||||
|
||||
List<UserParam> result = new ArrayList<>();
|
||||
|
||||
try (PreparedStatement ps = db.getConnection().prepareStatement(sql)) {
|
||||
ps.setLong(1, loginId);
|
||||
try (ResultSet rs = ps.executeQuery()) {
|
||||
while (rs.next()) result.add(mapRow(rs));
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private UserParam mapRow(ResultSet rs) throws SQLException {
|
||||
return new UserParam(
|
||||
rs.getLong("loginId"),
|
||||
rs.getString("param"),
|
||||
rs.getLong("bch_channel_id"),
|
||||
rs.getString("value"),
|
||||
rs.getLong("time_ms"),
|
||||
(short) rs.getInt("pubkey_num"),
|
||||
rs.getString("signature")
|
||||
);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,98 @@
|
||||
package shine.db.entities;
|
||||
|
||||
public class ActiveSession {
|
||||
|
||||
private long sessionId;
|
||||
private String sessionPwd;
|
||||
private long loginId;
|
||||
private long timeMs; // время в мс
|
||||
private short pubkeyNum;
|
||||
private String pushEndpoint;
|
||||
private String pushP256dhKey;
|
||||
private String pushAuthKey;
|
||||
|
||||
public ActiveSession() {
|
||||
}
|
||||
|
||||
public ActiveSession(long sessionId,
|
||||
String sessionPwd,
|
||||
long loginId,
|
||||
long timeMs,
|
||||
short pubkeyNum,
|
||||
String pushEndpoint,
|
||||
String pushP256dhKey,
|
||||
String pushAuthKey) {
|
||||
this.sessionId = sessionId;
|
||||
this.sessionPwd = sessionPwd;
|
||||
this.loginId = loginId;
|
||||
this.timeMs = timeMs;
|
||||
this.pubkeyNum = pubkeyNum;
|
||||
this.pushEndpoint = pushEndpoint;
|
||||
this.pushP256dhKey = pushP256dhKey;
|
||||
this.pushAuthKey = pushAuthKey;
|
||||
}
|
||||
|
||||
public long getSessionId() {
|
||||
return sessionId;
|
||||
}
|
||||
|
||||
public void setSessionId(long sessionId) {
|
||||
this.sessionId = sessionId;
|
||||
}
|
||||
|
||||
public String getSessionPwd() {
|
||||
return sessionPwd;
|
||||
}
|
||||
|
||||
public void setSessionPwd(String sessionPwd) {
|
||||
this.sessionPwd = sessionPwd;
|
||||
}
|
||||
|
||||
public long getLoginId() {
|
||||
return loginId;
|
||||
}
|
||||
|
||||
public void setLoginId(long loginId) {
|
||||
this.loginId = loginId;
|
||||
}
|
||||
|
||||
public long getTimeMs() {
|
||||
return timeMs;
|
||||
}
|
||||
|
||||
public void setTimeMs(long timeMs) {
|
||||
this.timeMs = timeMs;
|
||||
}
|
||||
|
||||
public short getPubkeyNum() {
|
||||
return pubkeyNum;
|
||||
}
|
||||
|
||||
public void setPubkeyNum(short pubkeyNum) {
|
||||
this.pubkeyNum = pubkeyNum;
|
||||
}
|
||||
|
||||
public String getPushEndpoint() {
|
||||
return pushEndpoint;
|
||||
}
|
||||
|
||||
public void setPushEndpoint(String pushEndpoint) {
|
||||
this.pushEndpoint = pushEndpoint;
|
||||
}
|
||||
|
||||
public String getPushP256dhKey() {
|
||||
return pushP256dhKey;
|
||||
}
|
||||
|
||||
public void setPushP256dhKey(String pushP256dhKey) {
|
||||
this.pushP256dhKey = pushP256dhKey;
|
||||
}
|
||||
|
||||
public String getPushAuthKey() {
|
||||
return pushAuthKey;
|
||||
}
|
||||
|
||||
public void setPushAuthKey(String pushAuthKey) {
|
||||
this.pushAuthKey = pushAuthKey;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,76 @@
|
||||
package shine.db.entities;
|
||||
|
||||
public class SolanaUser {
|
||||
|
||||
private long loginId;
|
||||
private String login;
|
||||
private long bchId;
|
||||
private String pubkey0;
|
||||
private String pubkey1;
|
||||
private Integer bchLimit; // может быть null
|
||||
|
||||
public SolanaUser() {
|
||||
}
|
||||
|
||||
public SolanaUser(long loginId,
|
||||
String login,
|
||||
long bchId,
|
||||
String pubkey0,
|
||||
String pubkey1,
|
||||
Integer bchLimit) {
|
||||
this.loginId = loginId;
|
||||
this.login = login;
|
||||
this.bchId = bchId;
|
||||
this.pubkey0 = pubkey0;
|
||||
this.pubkey1 = pubkey1;
|
||||
this.bchLimit = bchLimit;
|
||||
}
|
||||
|
||||
public long getLoginId() {
|
||||
return loginId;
|
||||
}
|
||||
|
||||
public void setLoginId(long loginId) {
|
||||
this.loginId = loginId;
|
||||
}
|
||||
|
||||
public String getLogin() {
|
||||
return login;
|
||||
}
|
||||
|
||||
public void setLogin(String login) {
|
||||
this.login = login;
|
||||
}
|
||||
|
||||
public long getBchId() {
|
||||
return bchId;
|
||||
}
|
||||
|
||||
public void setBchId(long bchId) {
|
||||
this.bchId = bchId;
|
||||
}
|
||||
|
||||
public String getPubkey0() {
|
||||
return pubkey0;
|
||||
}
|
||||
|
||||
public void setPubkey0(String pubkey0) {
|
||||
this.pubkey0 = pubkey0;
|
||||
}
|
||||
|
||||
public String getPubkey1() {
|
||||
return pubkey1;
|
||||
}
|
||||
|
||||
public void setPubkey1(String pubkey1) {
|
||||
this.pubkey1 = pubkey1;
|
||||
}
|
||||
|
||||
public Integer getBchLimit() {
|
||||
return bchLimit;
|
||||
}
|
||||
|
||||
public void setBchLimit(Integer bchLimit) {
|
||||
this.bchLimit = bchLimit;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,87 @@
|
||||
package shine.db.entities;
|
||||
|
||||
public class UserParam {
|
||||
|
||||
private long loginId;
|
||||
private String param;
|
||||
private long bchChannelId; // новый канал, 8 байт, может быть 0
|
||||
private String value;
|
||||
private long timeMs; // время в мс
|
||||
private short pubkeyNum;
|
||||
private String signature;
|
||||
|
||||
public UserParam() {
|
||||
}
|
||||
|
||||
public UserParam(long loginId,
|
||||
String param,
|
||||
long bchChannelId,
|
||||
String value,
|
||||
long timeMs,
|
||||
short pubkeyNum,
|
||||
String signature) {
|
||||
this.loginId = loginId;
|
||||
this.param = param;
|
||||
this.bchChannelId = bchChannelId;
|
||||
this.value = value;
|
||||
this.timeMs = timeMs;
|
||||
this.pubkeyNum = pubkeyNum;
|
||||
this.signature = signature;
|
||||
}
|
||||
|
||||
public long getLoginId() {
|
||||
return loginId;
|
||||
}
|
||||
|
||||
public void setLoginId(long loginId) {
|
||||
this.loginId = loginId;
|
||||
}
|
||||
|
||||
public String getParam() {
|
||||
return param;
|
||||
}
|
||||
|
||||
public void setParam(String param) {
|
||||
this.param = param;
|
||||
}
|
||||
|
||||
public long getBchChannelId() {
|
||||
return bchChannelId;
|
||||
}
|
||||
|
||||
public void setBchChannelId(long bchChannelId) {
|
||||
this.bchChannelId = bchChannelId;
|
||||
}
|
||||
|
||||
public String getValue() {
|
||||
return value;
|
||||
}
|
||||
|
||||
public void setValue(String value) {
|
||||
this.value = value;
|
||||
}
|
||||
|
||||
public long getTimeMs() {
|
||||
return timeMs;
|
||||
}
|
||||
|
||||
public void setTimeMs(long timeMs) {
|
||||
this.timeMs = timeMs;
|
||||
}
|
||||
|
||||
public short getPubkeyNum() {
|
||||
return pubkeyNum;
|
||||
}
|
||||
|
||||
public void setPubkeyNum(short pubkeyNum) {
|
||||
this.pubkeyNum = pubkeyNum;
|
||||
}
|
||||
|
||||
public String getSignature() {
|
||||
return signature;
|
||||
}
|
||||
|
||||
public void setSignature(String signature) {
|
||||
this.signature = signature;
|
||||
}
|
||||
}
|
||||
44
shine-server-db/src/main/java/Описание таблиц в БД.md
Normal file
44
shine-server-db/src/main/java/Описание таблиц в БД.md
Normal file
@ -0,0 +1,44 @@
|
||||
# Структура БД SHiNE (кратко)
|
||||
|
||||
## Таблица `solana_users`
|
||||
Локальная копия данных о пользователях из Solana.
|
||||
|
||||
Поля:
|
||||
- `login` (TEXT) — логин пользователя.
|
||||
- `loginId` (INTEGER, PK) — ID пользователя, основной ключ.
|
||||
- `bchId` (INTEGER) — ID блокчейна пользователя.
|
||||
- `pubkey0` (TEXT) — первый публичный ключ.
|
||||
- `pubkey1` (TEXT) — второй публичный ключ.
|
||||
- `bchLimit` (INTEGER, NULL) — произвольный лимит для пользователя (опционально).
|
||||
|
||||
---
|
||||
|
||||
## Таблица `active_sessions`
|
||||
Активные сессии пользователей (WebSocket/WSS + Web Push).
|
||||
|
||||
Поля:
|
||||
- `sessionId` (INTEGER, PK) — ID сессии, генерируется приложением.
|
||||
- `session_pwd` (TEXT) — секрет/пароль сессии.
|
||||
- `loginId` (INTEGER, FK → solana_users.loginId) — владелец сессии.
|
||||
- `time_ms` (INTEGER) — время создания/активности сессии (мс от эпохи).
|
||||
- `pubkey_num` (INTEGER) — номер ключа пользователя, которым подписывались данные.
|
||||
- `push_endpoint` (TEXT, NULL) — endpoint Web Push.
|
||||
- `push_p256dh_key` (TEXT, NULL) — p256dh-ключ Web Push.
|
||||
- `push_auth_key` (TEXT, NULL) — auth-ключ Web Push.
|
||||
|
||||
---
|
||||
|
||||
## Таблица `users_params`
|
||||
Сохранённые параметры и состояния пользователя (например, до какого сообщения прочитана лента).
|
||||
|
||||
Поля:
|
||||
- `loginId` (INTEGER, FK → solana_users.loginId) — пользователь.
|
||||
- `param` (TEXT) — имя параметра (ключ).
|
||||
- `bch_channel_id` (INTEGER, DEFAULT 0) — ID канала/ленты который просмотрен.
|
||||
- `value` (TEXT, NULL) — значение параметра (строка).
|
||||
- `time_ms` (INTEGER) — время последнего обновления (мс от эпохи).
|
||||
- `pubkey_num` (INTEGER) — номер ключа, которым подписано значение.
|
||||
- `signature` (TEXT, NULL) — подпись значения.
|
||||
|
||||
Ограничения:
|
||||
- `UNIQUE(loginId, param)` — у одного пользователя каждый `param` только один раз.
|
||||
35
shine-server-net-protocol/build.gradle
Normal file
35
shine-server-net-protocol/build.gradle
Normal file
@ -0,0 +1,35 @@
|
||||
plugins {
|
||||
id 'java'
|
||||
}
|
||||
|
||||
group = 'shine'
|
||||
version = '1.0.0'
|
||||
|
||||
java {
|
||||
toolchain {
|
||||
languageVersion = JavaLanguageVersion.of(17)
|
||||
}
|
||||
}
|
||||
|
||||
repositories {
|
||||
mavenCentral()
|
||||
}
|
||||
|
||||
dependencies {
|
||||
implementation 'com.fasterxml.jackson.core:jackson-databind:2.17.1' // json
|
||||
|
||||
implementation 'org.slf4j:slf4j-api:2.0.9'
|
||||
implementation 'ch.qos.logback:logback-classic:1.5.6'
|
||||
|
||||
implementation project(':shine-server-config') // модуль с настройками
|
||||
implementation project(':shine-server-db') // модуль для работы с БД содержит и сущности из БД и саму работу с БД
|
||||
|
||||
}
|
||||
|
||||
java {
|
||||
sourceCompatibility = JavaVersion.VERSION_17
|
||||
targetCompatibility = JavaVersion.VERSION_17
|
||||
}
|
||||
|
||||
|
||||
|
||||
16
shine-server-net-protocol/concat_to_file.sh
Executable file
16
shine-server-net-protocol/concat_to_file.sh
Executable file
@ -0,0 +1,16 @@
|
||||
#!/usr/bin/env bash
|
||||
set -euo pipefail
|
||||
|
||||
OUTFILE="all_files.txt"
|
||||
|
||||
# очищаем или создаём файл
|
||||
: > "$OUTFILE"
|
||||
|
||||
# собрать только *.java файлы и вывести их содержимое в файл
|
||||
find . -type f -name "*.java" | sort | while read -r f; do
|
||||
cat "$f" >> "$OUTFILE"
|
||||
echo >> "$OUTFILE" # пустая строка-разделитель
|
||||
done
|
||||
|
||||
echo "Готово! Все .java файлы собраны в $OUTFILE"
|
||||
|
||||
@ -0,0 +1,137 @@
|
||||
package server.logic.ws_protocol.JSON;
|
||||
|
||||
/**
|
||||
* ConnectionContext — контекст состояния одного WebSocket-соединения.
|
||||
* Живёт ровно столько же, сколько живёт подключение.
|
||||
*/
|
||||
public class ConnectionContext {
|
||||
|
||||
// Статусы аутентификации
|
||||
public static final int AUTH_STATUS_NONE = 0; // ананимный или не авторизованный пользователь
|
||||
public static final int AUTH_STATUS_USER = 1; // авторизованный пользователь
|
||||
// public static final int AUTH_STATUS_ANON = 2; // анонимный (зарезервировано на будущее)
|
||||
|
||||
private String login;
|
||||
private Long loginId;
|
||||
|
||||
private Long sessionId;
|
||||
private String sessionPwd;
|
||||
|
||||
// Данные пользователя / блокчейна
|
||||
private Long bchId;
|
||||
private String pubkey0;
|
||||
private String pubkey1;
|
||||
private Integer bchLimit;
|
||||
|
||||
private int authenticationStatus = AUTH_STATUS_NONE;
|
||||
|
||||
// --- getters / setters ---
|
||||
|
||||
public String getLogin() {
|
||||
return login;
|
||||
}
|
||||
|
||||
public void setLogin(String login) {
|
||||
this.login = login;
|
||||
}
|
||||
|
||||
public Long getLoginId() {
|
||||
return loginId;
|
||||
}
|
||||
|
||||
public void setLoginId(Long loginId) {
|
||||
this.loginId = loginId;
|
||||
}
|
||||
|
||||
public Long getSessionId() {
|
||||
return sessionId;
|
||||
}
|
||||
|
||||
public void setSessionId(Long sessionId) {
|
||||
this.sessionId = sessionId;
|
||||
}
|
||||
|
||||
public String getSessionPwd() {
|
||||
return sessionPwd;
|
||||
}
|
||||
|
||||
public void setSessionPwd(String sessionPwd) {
|
||||
this.sessionPwd = sessionPwd;
|
||||
}
|
||||
|
||||
public Long getBchId() {
|
||||
return bchId;
|
||||
}
|
||||
|
||||
public void setBchId(Long bchId) {
|
||||
this.bchId = bchId;
|
||||
}
|
||||
|
||||
public String getPubkey0() {
|
||||
return pubkey0;
|
||||
}
|
||||
|
||||
public void setPubkey0(String pubkey0) {
|
||||
this.pubkey0 = pubkey0;
|
||||
}
|
||||
|
||||
public String getPubkey1() {
|
||||
return pubkey1;
|
||||
}
|
||||
|
||||
public void setPubkey1(String pubkey1) {
|
||||
this.pubkey1 = pubkey1;
|
||||
}
|
||||
|
||||
public Integer getBchLimit() {
|
||||
return bchLimit;
|
||||
}
|
||||
|
||||
public void setBchLimit(Integer bchLimit) {
|
||||
this.bchLimit = bchLimit;
|
||||
}
|
||||
|
||||
public int getAuthenticationStatus() {
|
||||
return authenticationStatus;
|
||||
}
|
||||
|
||||
public void setAuthenticationStatus(int authenticationStatus) {
|
||||
this.authenticationStatus = authenticationStatus;
|
||||
}
|
||||
|
||||
public boolean isAuthenticatedUser() {
|
||||
return authenticationStatus == AUTH_STATUS_USER;
|
||||
}
|
||||
|
||||
public boolean isAnonymous() {
|
||||
return authenticationStatus == AUTH_STATUS_NONE;
|
||||
}
|
||||
|
||||
public void reset() {
|
||||
login = null;
|
||||
loginId = null;
|
||||
sessionId = null;
|
||||
sessionPwd = null;
|
||||
|
||||
bchId = null;
|
||||
pubkey0 = null;
|
||||
pubkey1 = null;
|
||||
bchLimit = null;
|
||||
|
||||
authenticationStatus = AUTH_STATUS_NONE;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return "ConnectionContext{" +
|
||||
"login='" + login + '\'' +
|
||||
", loginId=" + loginId +
|
||||
", sessionId=" + sessionId +
|
||||
", bchId=" + bchId +
|
||||
", pubkey0='" + pubkey0 + '\'' +
|
||||
", pubkey1='" + pubkey1 + '\'' +
|
||||
", bchLimit=" + bchLimit +
|
||||
", authenticationStatus=" + authenticationStatus +
|
||||
'}';
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,49 @@
|
||||
package server.logic.ws_protocol.JSON;
|
||||
|
||||
import server.logic.ws_protocol.JSON.entyties.*;
|
||||
import server.logic.ws_protocol.JSON.entyties.Auth.NetAuthSessionNewStep1Request;
|
||||
import server.logic.ws_protocol.JSON.entyties.Auth.NetSessionRefreshRequest;
|
||||
import server.logic.ws_protocol.JSON.handlers.*;
|
||||
import server.logic.ws_protocol.JSON.entyties.tempToTest.NetAddUserRequest;
|
||||
import server.logic.ws_protocol.JSON.handlers.auth.NetAddUserHandler;
|
||||
import server.logic.ws_protocol.JSON.handlers.auth.NetAuthSessionNewStep1Handler;
|
||||
import server.logic.ws_protocol.JSON.handlers.auth.NetSessionRefreshHandler;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* JsonHandlerRegistry — единое место, где руками регистрируются
|
||||
* JSON-операции: op → handler и op → requestClass.
|
||||
*
|
||||
* Если нужно добавить новый запрос:
|
||||
* 1) создаёшь класс NetXXXRequest / NetXXXResponse,
|
||||
* 2) создаёшь JsonMessageHandler (NetXXXHandler),
|
||||
* 3) добавляешь оп в HANDLERS и REQUEST_TYPES.
|
||||
*/
|
||||
public final class JsonHandlerRegistry {
|
||||
|
||||
private static final Map<String, JsonMessageHandler> HANDLERS = Map.of(
|
||||
"SessionRefresh", new NetSessionRefreshHandler(),
|
||||
"AddUser", new NetAddUserHandler(),
|
||||
"AuthSessionNewStep1", new NetAuthSessionNewStep1Handler()
|
||||
// сюда потом добавишь другие операции
|
||||
);
|
||||
|
||||
private static final Map<String, Class<? extends NetRequest>> REQUEST_TYPES = Map.of(
|
||||
"SessionRefresh", NetSessionRefreshRequest.class,
|
||||
"AddUser", NetAddUserRequest.class,
|
||||
"AuthSessionNewStep1", NetAuthSessionNewStep1Request.class
|
||||
);
|
||||
|
||||
private JsonHandlerRegistry() {
|
||||
// utility
|
||||
}
|
||||
|
||||
public static Map<String, JsonMessageHandler> getHandlers() {
|
||||
return HANDLERS;
|
||||
}
|
||||
|
||||
public static Map<String, Class<? extends NetRequest>> getRequestTypes() {
|
||||
return REQUEST_TYPES;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,158 @@
|
||||
package server.logic.ws_protocol.JSON;
|
||||
|
||||
import com.fasterxml.jackson.databind.JsonNode;
|
||||
import com.fasterxml.jackson.databind.ObjectMapper;
|
||||
import com.fasterxml.jackson.databind.node.ObjectNode;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
import server.logic.ws_protocol.JSON.entyties.NetRequest;
|
||||
import server.logic.ws_protocol.JSON.entyties.NetResponse;
|
||||
import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler;
|
||||
import server.logic.ws_protocol.WireCodes;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* JsonInboundProcessor — отдельный класс для обработки JSON-сообщений.
|
||||
*
|
||||
* 1) Парсит общий пакет (op, requestId, payload).
|
||||
* 2) По op выбирает класс запроса и хэндлер.
|
||||
* 3) Маппит JSON → NetRequest через ObjectMapper.
|
||||
* 4) Вызывает хэндлер, получает NetResponse.
|
||||
* 5) Собирает JSON-ответ и возвращает строкой.
|
||||
*/
|
||||
public final class JsonInboundProcessor {
|
||||
private static final Logger log = LoggerFactory.getLogger(JsonInboundProcessor.class);
|
||||
|
||||
private static final ObjectMapper JSON_MAPPER = new ObjectMapper();
|
||||
|
||||
/**
|
||||
* op → хэндлер.
|
||||
* Регистрация вынесена в JsonHandlerRegistry.
|
||||
*/
|
||||
private static final Map<String, JsonMessageHandler> JSON_HANDLERS =
|
||||
JsonHandlerRegistry.getHandlers();
|
||||
|
||||
/**
|
||||
* op → класс запроса.
|
||||
*/
|
||||
private static final Map<String, Class<? extends NetRequest>> JSON_REQUEST_TYPES =
|
||||
JsonHandlerRegistry.getRequestTypes();
|
||||
|
||||
private JsonInboundProcessor() {}
|
||||
|
||||
/**
|
||||
* Обработка входящего JSON-сообщения.
|
||||
*
|
||||
* @param json исходная строка от клиента
|
||||
* @param ctx контекст текущего WebSocket-соединения
|
||||
* @return JSON-строка ответа
|
||||
*/
|
||||
public static String processJson(String json, ConnectionContext ctx) {
|
||||
try {
|
||||
if (json == null || json.isBlank()) {
|
||||
return buildErrorJson(null, null, WireCodes.Status.BAD_REQUEST,
|
||||
"EMPTY_JSON", "Пустое JSON-сообщение");
|
||||
}
|
||||
|
||||
// 1. Парсим общий пакет как дерево
|
||||
JsonNode root = JSON_MAPPER.readTree(json);
|
||||
|
||||
// 2. Берём op и requestId
|
||||
String op = getTextOrNull(root, "op");
|
||||
if (op == null || op.isEmpty()) {
|
||||
return buildErrorJson(null, null, WireCodes.Status.BAD_REQUEST,
|
||||
"NO_OP", "Поле 'op' отсутствует или пустое");
|
||||
}
|
||||
|
||||
String requestId = getTextOrNull(root, "requestId");
|
||||
|
||||
JsonMessageHandler handler = JSON_HANDLERS.get(op);
|
||||
Class<? extends NetRequest> reqClass = JSON_REQUEST_TYPES.get(op);
|
||||
|
||||
if (handler == null || reqClass == null) {
|
||||
return buildErrorJson(op, requestId, WireCodes.Status.BAD_REQUEST,
|
||||
"UNKNOWN_OP", "Неизвестная операция: " + op);
|
||||
}
|
||||
|
||||
// 3. Маппим весь JSON в конкретный класс запроса
|
||||
NetRequest request = JSON_MAPPER.treeToValue(root, reqClass);
|
||||
|
||||
// 4. Вызываем хэндлер, передавая контекст
|
||||
NetResponse response = handler.handle(request, ctx);
|
||||
|
||||
// На всякий случай: если хэндлер не выставил op/requestId
|
||||
if (response.getOp() == null) {
|
||||
response.setOp(op);
|
||||
}
|
||||
if (response.getRequestId() == null) {
|
||||
response.setRequestId(requestId);
|
||||
}
|
||||
|
||||
// 5. Собираем JSON-ответ
|
||||
ObjectNode out = JSON_MAPPER.createObjectNode();
|
||||
out.put("op", response.getOp());
|
||||
out.put("requestId", response.getRequestId());
|
||||
out.put("status", response.getStatus());
|
||||
|
||||
if (response.getPayload() != null) {
|
||||
out.set("payload", JSON_MAPPER.valueToTree(response.getPayload()));
|
||||
} else {
|
||||
out.putNull("payload");
|
||||
}
|
||||
|
||||
return JSON_MAPPER.writeValueAsString(out);
|
||||
|
||||
} catch (Exception e) {
|
||||
log.error("Ошибка при обработке JSON-сообщения", e);
|
||||
return buildErrorJson("Unknown", null, WireCodes.Status.INTERNAL_ERROR,
|
||||
"INTERNAL_ERROR", "Внутренняя ошибка сервера");
|
||||
}
|
||||
}
|
||||
|
||||
// --- helper'ы ---
|
||||
|
||||
private static String getTextOrNull(JsonNode node, String field) {
|
||||
if (node == null || !node.has(field) || node.get(field).isNull()) return null;
|
||||
return node.get(field).asText();
|
||||
}
|
||||
|
||||
/**
|
||||
* Генерация JSON-ошибки в формате ответа:
|
||||
* {
|
||||
* "op": op,
|
||||
* "requestId": requestId,
|
||||
* "status": status,
|
||||
* "payload": {
|
||||
* "code": errorCode,
|
||||
* "message": errorMessage
|
||||
* }
|
||||
* }
|
||||
*/
|
||||
private static String buildErrorJson(String op,
|
||||
String requestId,
|
||||
int status,
|
||||
String errorCode,
|
||||
String errorMessage) {
|
||||
try {
|
||||
ObjectNode root = JSON_MAPPER.createObjectNode();
|
||||
|
||||
if (op != null) root.put("op", op); else root.putNull("op");
|
||||
if (requestId != null) root.put("requestId", requestId); else root.putNull("requestId");
|
||||
|
||||
root.put("status", status);
|
||||
|
||||
ObjectNode payload = root.putObject("payload");
|
||||
payload.put("code", errorCode);
|
||||
payload.put("message", errorMessage);
|
||||
|
||||
return JSON_MAPPER.writeValueAsString(root);
|
||||
} catch (Exception e) {
|
||||
return "{\"op\":\"" + (op != null ? op : "") +
|
||||
"\",\"requestId\":\"" + (requestId != null ? requestId : "") +
|
||||
"\",\"status\":" + status +
|
||||
",\"payload\":{\"code\":\"" + errorCode +
|
||||
"\",\"message\":\"" + errorMessage + "\"}}";
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,14 @@
|
||||
package server.logic.ws_protocol.JSON.entyties.Auth;
|
||||
|
||||
import server.logic.ws_protocol.JSON.entyties.NetRequest;
|
||||
|
||||
public class NetAuthSessionNewStep1Request extends NetRequest {
|
||||
private String login;
|
||||
|
||||
public String getLogin() {
|
||||
return login;
|
||||
}
|
||||
public void setLogin(String login) {
|
||||
this.login = login;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,14 @@
|
||||
package server.logic.ws_protocol.JSON.entyties.Auth;
|
||||
|
||||
import server.logic.ws_protocol.JSON.entyties.NetResponse;
|
||||
|
||||
public class NetAuthSessionNewStep1Response extends NetResponse {
|
||||
private String sessionPwd;
|
||||
|
||||
public String getSessionPwd() {
|
||||
return sessionPwd;
|
||||
}
|
||||
public void setSessionPwd(String sessionPwd) {
|
||||
this.sessionPwd = sessionPwd;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,34 @@
|
||||
package server.logic.ws_protocol.JSON.entyties.Auth;
|
||||
|
||||
import server.logic.ws_protocol.JSON.entyties.NetRequest;
|
||||
|
||||
/**
|
||||
* Запрос SessionRefresh.
|
||||
*
|
||||
* JSON (payload):
|
||||
* {
|
||||
* "sessionId": 123,
|
||||
* "sessionPwd": "abcd..."
|
||||
* }
|
||||
*/
|
||||
public class NetSessionRefreshRequest extends NetRequest {
|
||||
|
||||
private long sessionId;
|
||||
private String sessionPwd;
|
||||
|
||||
public long getSessionId() {
|
||||
return sessionId;
|
||||
}
|
||||
|
||||
public void setSessionId(long sessionId) {
|
||||
this.sessionId = sessionId;
|
||||
}
|
||||
|
||||
public String getSessionPwd() {
|
||||
return sessionPwd;
|
||||
}
|
||||
|
||||
public void setSessionPwd(String sessionPwd) {
|
||||
this.sessionPwd = sessionPwd;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,12 @@
|
||||
package server.logic.ws_protocol.JSON.entyties.Auth;
|
||||
|
||||
import server.logic.ws_protocol.JSON.entyties.NetResponse;
|
||||
|
||||
/**
|
||||
* Успешный ответ на SessionRefresh.
|
||||
*
|
||||
* Дополнительных полей нет, достаточно status=200 и (опционально) пустого payload.
|
||||
*/
|
||||
public class NetSessionRefreshResponse extends NetResponse {
|
||||
// Ничего дополнительного, вся информация в status.
|
||||
}
|
||||
@ -0,0 +1,41 @@
|
||||
package server.logic.ws_protocol.JSON.entyties;
|
||||
|
||||
/**
|
||||
* Базовый класс для всех событий (event).
|
||||
* Общие поля: op и payload.
|
||||
*
|
||||
* Формат JSON (event):
|
||||
* {
|
||||
* "op": "...",
|
||||
* "payload": { ... }
|
||||
* }
|
||||
*/
|
||||
public abstract class NetEvent {
|
||||
|
||||
/** Имя операции / события (op). */
|
||||
private String op;
|
||||
|
||||
/**
|
||||
* Произвольные данные.
|
||||
* В JSON это поле "payload".
|
||||
*/
|
||||
private Object payload;
|
||||
|
||||
// --- getters / setters ---
|
||||
|
||||
public String getOp() {
|
||||
return op;
|
||||
}
|
||||
|
||||
public void setOp(String op) {
|
||||
this.op = op;
|
||||
}
|
||||
|
||||
public Object getPayload() {
|
||||
return payload;
|
||||
}
|
||||
|
||||
public void setPayload(Object payload) {
|
||||
this.payload = payload;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,14 @@
|
||||
package server.logic.ws_protocol.JSON.entyties;
|
||||
|
||||
/**
|
||||
* Ответ с ошибкой (любой отказ).
|
||||
*
|
||||
* В payload лежит:
|
||||
* {
|
||||
* "code": "...",
|
||||
* "message": "..."
|
||||
* }
|
||||
*/
|
||||
public class NetExceptionResponse extends NetResponse {
|
||||
// Ничего дополнительного: код/текст ошибки лежат в payload (Map или DTO).
|
||||
}
|
||||
@ -0,0 +1,29 @@
|
||||
package server.logic.ws_protocol.JSON.entyties;
|
||||
|
||||
/**
|
||||
* Базовый класс для всех запросов (client → server).
|
||||
*
|
||||
* Наследуется от NetEvent и добавляет requestId.
|
||||
*
|
||||
* Формат JSON (request):
|
||||
* {
|
||||
* "op": "...",
|
||||
* "requestId": "...",
|
||||
* "payload": { ... }
|
||||
* }
|
||||
*/
|
||||
public abstract class NetRequest extends NetEvent {
|
||||
|
||||
/** Идентификатор запроса, чтобы связать запрос и ответ. */
|
||||
private String requestId;
|
||||
|
||||
// --- getters / setters ---
|
||||
|
||||
public String getRequestId() {
|
||||
return requestId;
|
||||
}
|
||||
|
||||
public void setRequestId(String requestId) {
|
||||
this.requestId = requestId;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,34 @@
|
||||
package server.logic.ws_protocol.JSON.entyties;
|
||||
|
||||
/**
|
||||
* Базовый класс для всех ответов (server → client).
|
||||
*
|
||||
* Наследуется от NetRequest и добавляет status.
|
||||
*
|
||||
* Формат JSON (response):
|
||||
* {
|
||||
* "op": "...",
|
||||
* "requestId": "...",
|
||||
* "status": 200,
|
||||
* "payload": { ... } // и для успеха, и для ошибки
|
||||
* }
|
||||
*/
|
||||
public abstract class NetResponse extends NetRequest {
|
||||
|
||||
/** Статус результата (200 — успех, любое другое значение — ошибка). */
|
||||
private int status;
|
||||
|
||||
// --- getters / setters ---
|
||||
|
||||
public int getStatus() {
|
||||
return status;
|
||||
}
|
||||
|
||||
public void setStatus(int status) {
|
||||
this.status = status;
|
||||
}
|
||||
|
||||
public boolean isOk() {
|
||||
return status == 200;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,76 @@
|
||||
package server.logic.ws_protocol.JSON.entyties.tempToTest;
|
||||
|
||||
import server.logic.ws_protocol.JSON.entyties.NetRequest;
|
||||
|
||||
/**
|
||||
* Запрос AddUser.
|
||||
*
|
||||
* Ожидаемый JSON:
|
||||
* {
|
||||
* "op": "AddUser",
|
||||
* "requestId": "...",
|
||||
* "login": "...",
|
||||
* "loginId": 123,
|
||||
* "bchId": 456,
|
||||
* "pubkey0": "...",
|
||||
* "pubkey1": "...",
|
||||
* "bchLimit": 1000
|
||||
* }
|
||||
*/
|
||||
public class NetAddUserRequest extends NetRequest {
|
||||
|
||||
private String login;
|
||||
private long loginId;
|
||||
private long bchId;
|
||||
private String pubkey0;
|
||||
private String pubkey1;
|
||||
private Integer bchLimit;
|
||||
|
||||
public String getLogin() {
|
||||
return login;
|
||||
}
|
||||
|
||||
public void setLogin(String login) {
|
||||
this.login = login;
|
||||
}
|
||||
|
||||
public long getLoginId() {
|
||||
return loginId;
|
||||
}
|
||||
|
||||
public void setLoginId(long loginId) {
|
||||
this.loginId = loginId;
|
||||
}
|
||||
|
||||
public long getBchId() {
|
||||
return bchId;
|
||||
}
|
||||
|
||||
public void setBchId(long bchId) {
|
||||
this.bchId = bchId;
|
||||
}
|
||||
|
||||
public String getPubkey0() {
|
||||
return pubkey0;
|
||||
}
|
||||
|
||||
public void setPubkey0(String pubkey0) {
|
||||
this.pubkey0 = pubkey0;
|
||||
}
|
||||
|
||||
public String getPubkey1() {
|
||||
return pubkey1;
|
||||
}
|
||||
|
||||
public void setPubkey1(String pubkey1) {
|
||||
this.pubkey1 = pubkey1;
|
||||
}
|
||||
|
||||
public Integer getBchLimit() {
|
||||
return bchLimit;
|
||||
}
|
||||
|
||||
public void setBchLimit(Integer bchLimit) {
|
||||
this.bchLimit = bchLimit;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,11 @@
|
||||
package server.logic.ws_protocol.JSON.entyties.tempToTest;
|
||||
|
||||
import server.logic.ws_protocol.JSON.entyties.NetResponse;
|
||||
|
||||
/**
|
||||
* Успешный ответ на AddUser.
|
||||
* Дополнительных полей нет — достаточно status=200.
|
||||
*/
|
||||
public class NetAddUserResponse extends NetResponse {
|
||||
// Можно потом добавить какие-то данные, если понадобится.
|
||||
}
|
||||
@ -0,0 +1,19 @@
|
||||
package server.logic.ws_protocol.JSON.handlers;
|
||||
|
||||
import server.logic.ws_protocol.JSON.ConnectionContext;
|
||||
import server.logic.ws_protocol.JSON.entyties.NetRequest;
|
||||
import server.logic.ws_protocol.JSON.entyties.NetResponse;
|
||||
|
||||
/**
|
||||
* Общий интерфейс для всех JSON-хэндлеров.
|
||||
*/
|
||||
public interface JsonMessageHandler {
|
||||
|
||||
/**
|
||||
* Обработать запрос и вернуть ответ.
|
||||
*
|
||||
* @param request распарсенный запрос
|
||||
* @param ctx контекст текущего WebSocket-соединения
|
||||
*/
|
||||
NetResponse handle(NetRequest request, ConnectionContext ctx) throws Exception;
|
||||
}
|
||||
@ -0,0 +1,98 @@
|
||||
package server.logic.ws_protocol.JSON.handlers.auth;
|
||||
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
import server.logic.ws_protocol.JSON.ConnectionContext;
|
||||
import server.logic.ws_protocol.JSON.entyties.tempToTest.NetAddUserRequest;
|
||||
import server.logic.ws_protocol.JSON.entyties.tempToTest.NetAddUserResponse;
|
||||
import server.logic.ws_protocol.JSON.entyties.NetExceptionResponse;
|
||||
import server.logic.ws_protocol.JSON.entyties.NetRequest;
|
||||
import server.logic.ws_protocol.JSON.entyties.NetResponse;
|
||||
import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler;
|
||||
import server.logic.ws_protocol.WireCodes;
|
||||
import shine.db.dao.SolanaUsersDAO;
|
||||
import shine.db.entities.SolanaUser;
|
||||
|
||||
import java.sql.SQLException;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Временный Хэндлер AddUser. Используется для тестовой регистрации!!!!!!!!
|
||||
*
|
||||
* Логика:
|
||||
* - берём login, loginId, bchId, pubkey0, pubkey1, bchLimit;
|
||||
* - создаём SolanaUser и вставляем через SolanaUsersDAO;
|
||||
* - если всё ОК → NetAddUserResponse со статусом 200;
|
||||
* - если ошибка БД или некорректные данные → NetExceptionResponse.
|
||||
*/
|
||||
public class NetAddUserHandler implements JsonMessageHandler {
|
||||
|
||||
private static final Logger log = LoggerFactory.getLogger(NetAddUserHandler.class);
|
||||
|
||||
@Override
|
||||
public NetResponse handle(NetRequest baseRequest, ConnectionContext ctx) throws Exception {
|
||||
NetAddUserRequest req = (NetAddUserRequest) baseRequest;
|
||||
|
||||
// Минимальная валидация входных данных
|
||||
if (req.getLogin() == null || req.getLogin().isBlank()) {
|
||||
return buildError(req, WireCodes.Status.BAD_REQUEST,
|
||||
"BAD_LOGIN", "Пустой логин");
|
||||
}
|
||||
if (req.getPubkey0() == null || req.getPubkey0().isBlank()
|
||||
|| req.getPubkey1() == null || req.getPubkey1().isBlank()) {
|
||||
return buildError(req, WireCodes.Status.BAD_REQUEST,
|
||||
"BAD_PUBKEY", "Публичные ключи не указаны");
|
||||
}
|
||||
if (req.getBchLimit() == null) {
|
||||
return buildError(req, WireCodes.Status.BAD_REQUEST,
|
||||
"BAD_BCH_LIMIT", "Не указан лимит блокчейна");
|
||||
}
|
||||
|
||||
try {
|
||||
SolanaUsersDAO dao = SolanaUsersDAO.getInstance();
|
||||
|
||||
SolanaUser user = new SolanaUser(
|
||||
req.getLoginId(),
|
||||
req.getLogin(),
|
||||
req.getBchId(),
|
||||
req.getPubkey0(),
|
||||
req.getPubkey1(),
|
||||
req.getBchLimit()
|
||||
);
|
||||
|
||||
dao.insert(user);
|
||||
|
||||
NetAddUserResponse resp = new NetAddUserResponse();
|
||||
resp.setOp(req.getOp());
|
||||
resp.setRequestId(req.getRequestId());
|
||||
resp.setStatus(WireCodes.Status.OK);
|
||||
resp.setPayload(null); // можно поставить Map.of("ok", true)
|
||||
log.info("✅ Пользователь добавлен: login={}, loginId={}", req.getLogin(), req.getLoginId());
|
||||
return resp;
|
||||
|
||||
} catch (SQLException e) {
|
||||
log.error("❌ Ошибка при вставке пользователя в БД", e);
|
||||
return buildError(req, WireCodes.Status.SERVER_DATA_ERROR,
|
||||
"DB_ERROR", "Ошибка доступа к базе данных");
|
||||
} catch (Exception e) {
|
||||
log.error("❌ Неожиданная ошибка в AddUser", e);
|
||||
return buildError(req, WireCodes.Status.INTERNAL_ERROR,
|
||||
"INTERNAL_ERROR", "Внутренняя ошибка сервера");
|
||||
}
|
||||
}
|
||||
|
||||
private NetExceptionResponse buildError(NetRequest req,
|
||||
int status,
|
||||
String code,
|
||||
String message) {
|
||||
NetExceptionResponse resp = new NetExceptionResponse();
|
||||
resp.setOp(req.getOp());
|
||||
resp.setRequestId(req.getRequestId());
|
||||
resp.setStatus(status);
|
||||
resp.setPayload(Map.of(
|
||||
"code", code,
|
||||
"message", message
|
||||
));
|
||||
return resp;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,79 @@
|
||||
package server.logic.ws_protocol.JSON.handlers.auth;
|
||||
|
||||
import server.logic.ws_protocol.JSON.ConnectionContext;
|
||||
import server.logic.ws_protocol.JSON.entyties.*;
|
||||
import server.logic.ws_protocol.JSON.entyties.Auth.NetAuthSessionNewStep1Request;
|
||||
import server.logic.ws_protocol.JSON.entyties.Auth.NetAuthSessionNewStep1Response;
|
||||
import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler;
|
||||
import server.logic.ws_protocol.WireCodes;
|
||||
import shine.db.dao.SolanaUsersDAO;
|
||||
import shine.db.entities.SolanaUser;
|
||||
|
||||
import java.security.SecureRandom;
|
||||
import java.util.Map;
|
||||
|
||||
public class NetAuthSessionNewStep1Handler implements JsonMessageHandler {
|
||||
|
||||
private static final SecureRandom RANDOM = new SecureRandom();
|
||||
|
||||
@Override
|
||||
public NetResponse handle(NetRequest baseReq, ConnectionContext ctx) throws Exception {
|
||||
|
||||
NetAuthSessionNewStep1Request req = (NetAuthSessionNewStep1Request) baseReq;
|
||||
|
||||
String login = req.getLogin();
|
||||
if (login == null || login.isBlank()) {
|
||||
return error(req, WireCodes.Status.BAD_REQUEST,
|
||||
"EMPTY_LOGIN", "Пустой логин");
|
||||
}
|
||||
|
||||
// 1) Проверка: в контексте никто не авторизован
|
||||
if (ctx.getLogin() != null) {
|
||||
return error(req, WireCodes.Status.BAD_REQUEST,
|
||||
"ALREADY_AUTHED",
|
||||
"Попытка повторной авторификации для уже заданного login=" + ctx.getLogin());
|
||||
}
|
||||
|
||||
// 2) Ищем пользователя в локальной БД
|
||||
SolanaUser solanaUser = SolanaUsersDAO.getInstance().getByLogin(login);
|
||||
|
||||
if (solanaUser == null) {
|
||||
// TODO позже — запрос в Solana, если не нашли локально
|
||||
return error(req, WireCodes.Status.UNVERIFIED,
|
||||
"UNKNOWN_USER", "Пользователь с таким логином не найден");
|
||||
}
|
||||
|
||||
// 3) Заполняем контекст полями пользователя
|
||||
ctx.setLogin(solanaUser.getLogin());
|
||||
ctx.setLoginId(solanaUser.getLoginId());
|
||||
ctx.setBchId(solanaUser.getBchId());
|
||||
ctx.setPubkey0(solanaUser.getPubkey0());
|
||||
ctx.setPubkey1(solanaUser.getPubkey1());
|
||||
ctx.setBchLimit(solanaUser.getBchLimit());
|
||||
|
||||
// 4) Генерируем надёжный sessionPwd
|
||||
// SecureRandom + время → достаточно
|
||||
String sessionPwd = Long.toHexString(System.nanoTime()) +
|
||||
Long.toHexString(RANDOM.nextLong());
|
||||
|
||||
ctx.setSessionPwd(sessionPwd);
|
||||
|
||||
// 5) Формируем ответ
|
||||
NetAuthSessionNewStep1Response resp = new NetAuthSessionNewStep1Response();
|
||||
resp.setOp(req.getOp());
|
||||
resp.setRequestId(req.getRequestId());
|
||||
resp.setStatus(WireCodes.Status.OK);
|
||||
resp.setPayload(Map.of("sessionPwd", sessionPwd));
|
||||
|
||||
return resp;
|
||||
}
|
||||
|
||||
private NetExceptionResponse error(NetRequest req, int status, String code, String msg) {
|
||||
NetExceptionResponse resp = new NetExceptionResponse();
|
||||
resp.setOp(req.getOp());
|
||||
resp.setRequestId(req.getRequestId());
|
||||
resp.setStatus(status);
|
||||
resp.setPayload(Map.of("code", code, "message", msg));
|
||||
return resp;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,94 @@
|
||||
package server.logic.ws_protocol.JSON.handlers.auth;
|
||||
|
||||
import server.logic.ws_protocol.JSON.ConnectionContext;
|
||||
import server.logic.ws_protocol.JSON.entyties.NetExceptionResponse;
|
||||
import server.logic.ws_protocol.JSON.entyties.NetRequest;
|
||||
import server.logic.ws_protocol.JSON.entyties.NetResponse;
|
||||
import server.logic.ws_protocol.JSON.entyties.Auth.NetSessionRefreshRequest;
|
||||
import server.logic.ws_protocol.JSON.entyties.Auth.NetSessionRefreshResponse;
|
||||
import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler;
|
||||
import server.logic.ws_protocol.WireCodes;
|
||||
import shine.db.dao.ActiveSessionsDAO;
|
||||
import shine.db.entities.ActiveSession;
|
||||
|
||||
import java.sql.SQLException;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Хэндлер SessionRefresh.
|
||||
*
|
||||
* Логика:
|
||||
* - берём sessionId и sessionPwd из запроса;
|
||||
* - ищем сессию в БД;
|
||||
* - если не нашли или пароль не совпал → NetExceptionResponse;
|
||||
* - если всё ок:
|
||||
* * обновляем ConnectionContext (sessionId, sessionPwd, статус USER);
|
||||
* * возвращаем NetSessionRefreshResponse со статусом 200.
|
||||
*/
|
||||
public class NetSessionRefreshHandler implements JsonMessageHandler {
|
||||
|
||||
@Override
|
||||
public NetResponse handle(NetRequest request, ConnectionContext ctx) throws Exception {
|
||||
NetSessionRefreshRequest req = (NetSessionRefreshRequest) request;
|
||||
|
||||
long sessionId = req.getSessionId();
|
||||
String sessionPwd = req.getSessionPwd();
|
||||
|
||||
if (sessionPwd == null || sessionPwd.isEmpty()) {
|
||||
return buildError(req, WireCodes.Status.BAD_REQUEST,
|
||||
"BAD_SESSION_PWD", "Пустой пароль сессии");
|
||||
}
|
||||
|
||||
ActiveSessionsDAO dao = ActiveSessionsDAO.getInstance();
|
||||
ActiveSession session;
|
||||
try {
|
||||
session = dao.getBySessionId(sessionId);
|
||||
} catch (SQLException e) {
|
||||
// Ошибка БД → внутренняя ошибка сервера
|
||||
return buildError(req, WireCodes.Status.SERVER_DATA_ERROR,
|
||||
"DB_ERROR", "Ошибка доступа к базе данных");
|
||||
}
|
||||
|
||||
if (session == null) {
|
||||
return buildError(req, WireCodes.Status.UNVERIFIED,
|
||||
"SESSION_NOT_FOUND", "Сессия не найдена");
|
||||
}
|
||||
|
||||
String dbPwd = session.getSessionPwd();
|
||||
if (dbPwd == null || !dbPwd.equals(sessionPwd)) {
|
||||
return buildError(req, WireCodes.Status.UNVERIFIED,
|
||||
"SESSION_PWD_MISMATCH", "Неверный пароль сессии");
|
||||
}
|
||||
|
||||
// Всё хорошо — обновляем контекст соединения
|
||||
if (ctx != null) {
|
||||
ctx.setSessionId(sessionId);
|
||||
ctx.setSessionPwd(sessionPwd);
|
||||
// Если потом добавишь в ActiveSession login / loginId — можно здесь и их проставлять
|
||||
ctx.setAuthenticationStatus(ConnectionContext.AUTH_STATUS_USER);
|
||||
}
|
||||
|
||||
// И возвращаем OK без доп. данных
|
||||
NetSessionRefreshResponse resp = new NetSessionRefreshResponse();
|
||||
resp.setOp(req.getOp());
|
||||
resp.setRequestId(req.getRequestId());
|
||||
resp.setStatus(WireCodes.Status.OK);
|
||||
resp.setPayload(null); // или Map.of("ok", true)
|
||||
return resp;
|
||||
}
|
||||
|
||||
private NetExceptionResponse buildError(NetRequest req,
|
||||
int status,
|
||||
String code,
|
||||
String message) {
|
||||
NetExceptionResponse resp = new NetExceptionResponse();
|
||||
resp.setOp(req.getOp());
|
||||
resp.setRequestId(req.getRequestId());
|
||||
resp.setStatus(status);
|
||||
resp.setPayload(Map.of(
|
||||
"code", code,
|
||||
"message", message
|
||||
));
|
||||
return resp;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,52 @@
|
||||
Протокол использует единый формат JSON-сообщений: клиент всегда отправляет запросы с полями op, requestId и payload, сервер отвечает тем же op и requestId, добавляя status (200 для успеха, любое другое значение — ошибка) и либо payload, либо error.
|
||||
|
||||
События от сервера приходят без requestId и status, содержат только op и payload и не являются ответами на запросы.
|
||||
|
||||
# Примеры JSON для SearchUsers (минимальная шпаргалка)
|
||||
|
||||
## 🔵 Запрос (client → server)
|
||||
|
||||
```json
|
||||
{
|
||||
"op": "SearchUsers",
|
||||
"requestId": "req-1",
|
||||
"payload": {
|
||||
"query": "ai"
|
||||
}
|
||||
}
|
||||
|
||||
🟢 Успешный ответ (server → client)
|
||||
|
||||
{
|
||||
"op": "SearchUsers",
|
||||
"requestId": "req-1",
|
||||
"status": 200,
|
||||
"payload": {
|
||||
"users": [
|
||||
{ "login": "aidar" },
|
||||
{ "login": "anya" }
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
🔴 Ошибочный ответ (server → client)
|
||||
|
||||
{
|
||||
"op": "SearchUsers",
|
||||
"requestId": "req-1",
|
||||
"status": 403,
|
||||
"error": {
|
||||
"code": "SESSION_EXPIRED",
|
||||
"message": "Сессия истекла"
|
||||
}
|
||||
}
|
||||
|
||||
🟣 Событие (server → client, не ответ)
|
||||
|
||||
{
|
||||
"op": "NewBlockEvent",
|
||||
"payload": {
|
||||
"blockchainId": 42,
|
||||
"blockNumber": 101
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,102 @@
|
||||
package server.logic.ws_protocol;
|
||||
|
||||
/**
|
||||
* WireCodes — константы бинарного протокола поверх WebSocket.
|
||||
*
|
||||
* Формат входящего сообщения:
|
||||
* [4] int opCode (big-endian)
|
||||
* [*] payload
|
||||
*
|
||||
* Ответ сервера:
|
||||
* ровно [4] int statusCode (big-endian)
|
||||
*/
|
||||
public final class WireCodes {
|
||||
private WireCodes() {}
|
||||
|
||||
public static final class Op {
|
||||
public static final int PING = 0;
|
||||
public static final int ADD_BLOCK = 1;
|
||||
public static final int GET_BLOCKCHAIN = 2;
|
||||
public static final int SEARCH_USERS = 30;
|
||||
public static final int GET_LAST_BLOCK_INFO = 31;
|
||||
private Op() {}
|
||||
}
|
||||
|
||||
public static final class Status {
|
||||
public static final int PONG = 100; // ответ на PING
|
||||
// public static final int OK = 200; // успех
|
||||
|
||||
public static final int ALREADY_EXISTS = 409; // пришёл блок < N+1
|
||||
public static final int NON_SEQUENTIAL = 412; // пришёл блок > N+1
|
||||
|
||||
|
||||
private Status() {}
|
||||
|
||||
|
||||
|
||||
|
||||
// ============================================================
|
||||
// 🟢 УСПЕШНЫЕ ОПЕРАЦИИ
|
||||
// ============================================================
|
||||
|
||||
/** ✅ Блок успешно добавлен в цепочку. */
|
||||
public static final int OK = 200;
|
||||
|
||||
/** 🌱 Создана новая цепочка (первый блок-заголовок принят). */
|
||||
public static final int CHAIN_CREATED = 201;
|
||||
|
||||
/**
|
||||
* 🔁 Такой блок уже существует.
|
||||
* Клиент может считать это успешным ответом:
|
||||
* - сервер возвращает 8 байт: [4] код (202) + [4] номер последнего блока (int)
|
||||
* - клиент обновляет свой lastBlockNumber и не пересылает этот блок снова. */
|
||||
public static final int BLOCK_ALREADY_EXISTS = 202; // плюс к кодуследом возвращается номер последнего блока на сервере
|
||||
|
||||
|
||||
// ============================================================
|
||||
// 🟡 ЛОГИЧЕСКИЕ / ПРОТОКОЛЬНЫЕ ОШИБКИ
|
||||
// ============================================================
|
||||
|
||||
/** ⚠️ Нарушена последовательность — пришёл блок с номером > ожидаемого.
|
||||
* Сервер вернёт 8 байт: [4] код (409) + [4] последний номер блока.
|
||||
* Клиент должен дослать недостающие блоки. */
|
||||
public static final int OUT_OF_SEQUENCE = 409; // плюс к кодуследом возвращается номер последнего блока на сервере
|
||||
|
||||
/** ❌ Некорректные или неполные данные в запросе. */
|
||||
public static final int BAD_REQUEST = 400;
|
||||
|
||||
/** 🚫 Цепочка с указанным blockchainId не найдена. */
|
||||
public static final int CHAIN_NOT_FOUND = 404;
|
||||
|
||||
/** 🧩 Несовпадение blockchainId между заголовком блока и телом. */
|
||||
public static final int INVALID_BLOCKCHAIN_ID = 421;
|
||||
|
||||
/** ❌ Ошибка верификации блока — хэш или подпись не совпали.
|
||||
* 🔐 Ошибка хэша: SHA-256(preimage) не совпал с переданным hash32.
|
||||
* 🔏 Ошибка подписи Ed25519 — блок не прошёл криптографическую проверку. */
|
||||
public static final int UNVERIFIED = 422;
|
||||
|
||||
|
||||
/** 🙅 Некорректный логин (пустой, неверный формат, недопустимые символы). По сути вообще не может быть, тк логин проверяют при создании в другом блокчейне*/
|
||||
public static final int BAD_LOGIN = 462;
|
||||
|
||||
|
||||
// ============================================================
|
||||
// 🔴 СИСТЕМНЫЕ ОШИБКИ / ОГРАНИЧЕНИЯ
|
||||
// ============================================================
|
||||
|
||||
// ============================================================
|
||||
// 🔴 СИСТЕМНЫЕ ОШИБКИ / ОГРАНИЧЕНИЯ
|
||||
// ============================================================
|
||||
|
||||
/** 💾 Достигнут лимит размера блокчейна. */
|
||||
public static final int BLOCKCHAIN_FULL = 507;
|
||||
|
||||
/** 🧱 Ошибка при сохранении или обновлении данных на сервере (файлы, JSON и т.п.). */
|
||||
public static final int SERVER_DATA_ERROR = 501;
|
||||
|
||||
/** 💥 Общая внутренняя ошибка сервера (необработанное исключение). */
|
||||
public static final int INTERNAL_ERROR = 500;
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,29 @@
|
||||
Мини-памятка по JSON-протоколу
|
||||
** JsonInboundProcessor
|
||||
|
||||
Центральный вход для JSON.
|
||||
Принимает текст → парсит → ищет op → создаёт нужный NetRequest → вызывает хэндлер → возвращает JSON-ответ.
|
||||
|
||||
** JsonHandlerRegistry
|
||||
|
||||
Словарь операций.
|
||||
Связывает op → requestClass и op → handler.
|
||||
Любая новая операция регистрируется здесь.
|
||||
|
||||
** NetEvent / NetRequest / NetResponse
|
||||
|
||||
Базовые структуры JSON-протокола - от которых есть реализации для всех сущностей запросов ответов
|
||||
|
||||
** ConnectionContext
|
||||
|
||||
Хранит состояние текущего WebSocket-соединения: логин, sessionId, статус пользователя.
|
||||
Передаётся в любой JSON-хэндлер.
|
||||
|
||||
** JsonMessageHandler
|
||||
|
||||
Интерфейс одного хэндлера JSON-операции: - от которого наследуются все хэндлеры обработчики запросов
|
||||
handle(request, context) → NetResponse.
|
||||
|
||||
** WebSocket endpoint
|
||||
|
||||
BlockchainWsEndpoint.onText(...) получает строку → передаёт в JsonInboundProcessor → отправляет клиенту готовый JSON-ответ.
|
||||
36
shine-server-net-server/build.gradle
Normal file
36
shine-server-net-server/build.gradle
Normal file
@ -0,0 +1,36 @@
|
||||
plugins {
|
||||
id 'java'
|
||||
}
|
||||
|
||||
group = 'shine'
|
||||
version = '1.0.0'
|
||||
|
||||
java {
|
||||
toolchain {
|
||||
languageVersion = JavaLanguageVersion.of(17)
|
||||
}
|
||||
}
|
||||
|
||||
repositories {
|
||||
mavenCentral()
|
||||
}
|
||||
|
||||
dependencies {
|
||||
implementation project(':shine-server-config') // модуль с настройками
|
||||
implementation project(':shine-server-net-protocol')
|
||||
|
||||
// Jackson для JSON
|
||||
implementation 'com.fasterxml.jackson.core:jackson-databind:2.17.0'
|
||||
|
||||
// SLF4J API (если у тебя уже тянется из корня / других модулей, можно убрать)
|
||||
implementation 'org.slf4j:slf4j-api:2.0.13'
|
||||
|
||||
}
|
||||
|
||||
java {
|
||||
sourceCompatibility = JavaVersion.VERSION_17
|
||||
targetCompatibility = JavaVersion.VERSION_17
|
||||
}
|
||||
|
||||
|
||||
|
||||
0
src/TestJsonWsClient2
Normal file
0
src/TestJsonWsClient2
Normal file
10
src/main/docs/Запуск на сервере.txt
Normal file
10
src/main/docs/Запуск на сервере.txt
Normal file
@ -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
|
||||
13
src/main/docs/План работ до мвп/ДАО.md
Normal file
13
src/main/docs/План работ до мвп/ДАО.md
Normal file
@ -0,0 +1,13 @@
|
||||
Для того что бы работало ДАО SHiNE.DAO
|
||||
|
||||
Зарегить в дао в солане.
|
||||
Что бы в нём работало голосование на
|
||||
Перевод средств.
|
||||
Выдача лимита раздававть бонусы.
|
||||
На апдейт смарт кантрактов
|
||||
И посути на запуск любой программы в сол.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
67
src/main/docs/План работ до мвп/Инвестиции.md
Normal file
67
src/main/docs/План работ до мвп/Инвестиции.md
Normal file
@ -0,0 +1,67 @@
|
||||
Инвестиции считаем в USDT а вносим и выносим просто в соланах поо текущему курсу из оракула
|
||||
|
||||
НИКАНИХ замороженных NFT токенов валют и т.д.
|
||||
|
||||
Просто записи об очереди и вызов только через наш сайт!! //(И страницу дозаписи можно сделать фикированной в ARVEAVE)
|
||||
|
||||
Храним в одном пда реестре:
|
||||
сколько сколько сейчас в очереди записей,
|
||||
на какую сумму
|
||||
адрес последней записи.
|
||||
(Адрес записи-инвестиции это имя пользователя и номер записи)
|
||||
а так же сколько уже выплаченно
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Создание новой записи о инвестициях.
|
||||
|
||||
На каждого Пользователя-инвестора заводим вначале новый ПДА
|
||||
, а если он уже есть то просто увеличиваем размер старово ПДА и делаем дозапись
|
||||
|
||||
** В записи у пользователя храним.
|
||||
Её номер (то есть сколько до неё),
|
||||
Сумму в очереди до неё,
|
||||
Флаг что выплаченно
|
||||
Адрес СЛЕДУЮЩИЙ транцакции
|
||||
|
||||
|
||||
** Есть акаун реестр где указано сколько уже есть записей, на какую сумму и какой номер крайнейй записи
|
||||
|
||||
** И есть акаунт реестр на выплаты, в нём указано
|
||||
сколько по счёту записей уже выплаченно
|
||||
и на какую сумму уже выплаченно
|
||||
сколько USDT надо накопить на для следующей выплаты
|
||||
адрес (акаунт и номер записи)
|
||||
|
||||
** И вторая очеред для самых близких
|
||||
Там всё тоже самое что и в первой только суммы выплаты больше и даты непонятны
|
||||
|
||||
Полуается
|
||||
** добавить запись
|
||||
Прочитал главный реестр,
|
||||
И пда с крайней записью.
|
||||
Попробывал прочитать пда в который надо писать новую запись
|
||||
И дальше либо создал его или увеличил его размер на 1 запись
|
||||
И записал в него данные
|
||||
А в преведущую крайнюю запись добавил адрес следующей записи
|
||||
Обновил данные в реестре
|
||||
|
||||
** Прочитать данные для пользователя
|
||||
Прочитал Все записи из его пда
|
||||
Прочитал Сколько выплаченно прочитал из реестра на выплату
|
||||
Прочитал Сколько сейчас уже есть денег и сколько надо до следующей выплаты
|
||||
Пересчитал данные и показал пользователю в виде актуальной таблицы
|
||||
|
||||
** Сама выплата
|
||||
всё можно легко понять по аналогии с тем что выше написанно
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -0,0 +1,4 @@
|
||||
(При создании новых пользователей вообще не гоним о том что может быть конфликт если два чел в раз попытаются за регистрироваться
|
||||
т.к. даже при средней скорости 1 зарегистрированный чел в минуту будеит уже 43 200/мес,)
|
||||
|
||||
Поэтому делаем всю регистрацию одной транзакцией!! и не тупим пока об этом !!!
|
||||
29
src/main/docs/План работ до мвп/Функции в Solana.md
Normal file
29
src/main/docs/План работ до мвп/Функции в Solana.md
Normal file
@ -0,0 +1,29 @@
|
||||
|
||||
|
||||
|
||||
Зарегистрироваться
|
||||
|
||||
|
||||
Внести инвестиции (получить запись на бонус в 1 очередь)
|
||||
|
||||
Выдать (Записать комуто) бонус 1 очереди
|
||||
Выдать (Записать комуто) бонус второй очереди
|
||||
|
||||
Попробывать сделать шаг выплаты по очереди
|
||||
|
||||
Функции чтения
|
||||
Получить данные о пользователе
|
||||
Получить данные о пользователе(по логину, тоетсь по логину узнали ИД потом по ИД данные о пользователе)
|
||||
Получить данные об очереди выплат пользователя
|
||||
|
||||
Данные о пользователе по ИД подписанны ЦП пользователя (прямо в блокчейне!!)
|
||||
|
||||
|
||||
|
||||
|
||||
На одного пользователя храниться 2-3 пда
|
||||
ПДА ссылка по имени пользователя на ИД ПОльзователя
|
||||
ПДА по ИД пользователя со всеми его данными
|
||||
(И просто дописывать данные о каждом новом Bch пользователя иего пда по userИД)
|
||||
|
||||
|
||||
27
src/main/docs/Принципы сияния/Кто есть сияющие(5 пунктов).md
Normal file
27
src/main/docs/Принципы сияния/Кто есть сияющие(5 пунктов).md
Normal file
@ -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
|
||||
|
||||
|
||||
|
||||
Это чисто записи
|
||||
Добавить доверенного
|
||||
Убавить доверенного
|
||||
Добавить лимит
|
||||
|
||||
27
src/main/docs/Формат блоков/Что пишем в solana.md
Normal file
27
src/main/docs/Формат блоков/Что пишем в solana.md
Normal file
@ -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 @@
|
||||
Технический блокчен
|
||||
|
||||
Блоки в солану
|
||||
|
||||
Личнык данные
|
||||
Связи
|
||||
|
||||
|
||||
Публичные сообщения
|
||||
|
||||
|
||||
|
||||
Личые письма
|
||||
9
src/main/java/CreateNewDatabase.java
Normal file
9
src/main/java/CreateNewDatabase.java
Normal file
@ -0,0 +1,9 @@
|
||||
import shine.db.DatabaseInitializer;
|
||||
|
||||
public class CreateNewDatabase {
|
||||
|
||||
public static void main(String[] args) {
|
||||
// Просто прокидываем управление в DatabaseInitializer
|
||||
DatabaseInitializer.createNewDB(args);
|
||||
}
|
||||
}
|
||||
106
src/main/java/TestJsonWsClient.java
Normal file
106
src/main/java/TestJsonWsClient.java
Normal file
@ -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("Тест завершён, выходим.");
|
||||
}
|
||||
}
|
||||
119
src/main/java/TestJsonWsClient2.java
Normal file
119
src/main/java/TestJsonWsClient2.java
Normal file
@ -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("Тест завершён, выходим.");
|
||||
}
|
||||
}
|
||||
356
src/main/java/WsTestClient.java
Normal file
356
src/main/java/WsTestClient.java
Normal file
@ -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";
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
66
src/main/java/server/logic/InboundMessageProcessor.java
Normal file
66
src/main/java/server/logic/InboundMessageProcessor.java
Normal file
@ -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();
|
||||
}
|
||||
}
|
||||
141
src/main/java/server/ws/BlockchainWsEndpoint.java
Normal file
141
src/main/java/server/ws/BlockchainWsEndpoint.java
Normal file
@ -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-ошибка успешно отправлена");
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
85
src/main/java/server/ws/README.md
Normal file
85
src/main/java/server/ws/README.md
Normal file
@ -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-подключения, мост между сетью и логикой.
|
||||
48
src/main/java/server/ws/WsServer.java
Normal file
48
src/main/java/server/ws/WsServer.java
Normal file
@ -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();
|
||||
}
|
||||
}
|
||||
5
src/main/resources/application.properties
Normal file
5
src/main/resources/application.properties
Normal file
@ -0,0 +1,5 @@
|
||||
server.1port=7070
|
||||
|
||||
|
||||
db.path=data/shine.sqlite
|
||||
|
||||
33
src/main/resources/logback.xml
Normal file
33
src/main/resources/logback.xml
Normal file
@ -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>
|
||||
145
src/test_ws.html
Normal file
145
src/test_ws.html
Normal file
@ -0,0 +1,145 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="ru">
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<title>Blockchain WS Test</title>
|
||||
<style>
|
||||
body { font-family: monospace; background: #0d1117; color: #c9d1d9; padding: 20px; }
|
||||
h1 { color: #58a6ff; }
|
||||
#log { white-space: pre-wrap; border: 1px solid #30363d; padding: 10px; background: #161b22; height: 500px; overflow-y: auto; }
|
||||
button { background: #238636; color: white; border: none; padding: 10px 16px; border-radius: 6px; cursor: pointer; margin-right: 10px; }
|
||||
button:hover { background: #2ea043; }
|
||||
input { background: #0d1117; color: white; border: 1px solid #30363d; padding: 8px; border-radius: 6px; width: 300px; }
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
|
||||
<h1>🔗 WebSocket Blockchain Test</h1>
|
||||
<p>URL: <b>wss://shineup.me/ws</b></p>
|
||||
<button id="btnConnect">Connect</button>
|
||||
<button id="btnAddHeader">Add Header</button>
|
||||
<button id="btnGetChain">Get Chain</button>
|
||||
<br><br>
|
||||
<label for="textInput"></label><input id="textInput" placeholder="Введите текст для нового блока">
|
||||
<button id="btnAddText">Add Text</button>
|
||||
<br><br>
|
||||
<div id="log"></div>
|
||||
|
||||
<script>
|
||||
const log = msg => {
|
||||
const el = document.getElementById("log");
|
||||
el.textContent += msg + "\n";
|
||||
el.scrollTop = el.scrollHeight;
|
||||
};
|
||||
|
||||
// === Константы ===
|
||||
const WS_URL = "wss://shineup.me/ws";
|
||||
const OP_ADD_BLOCK = 1;
|
||||
const OP_GET_BLOCKCHAIN = 2;
|
||||
const TYPE_HEADER = 0;
|
||||
const TYPE_TEXT = 1;
|
||||
|
||||
let ws;
|
||||
let blockchainId = 777000001n;
|
||||
let userLogin = "test_user_js";
|
||||
|
||||
function beInt(v) {
|
||||
const buf = new ArrayBuffer(4);
|
||||
new DataView(buf).setInt32(0, v, false);
|
||||
return new Uint8Array(buf);
|
||||
}
|
||||
function beLong(v) {
|
||||
const buf = new ArrayBuffer(8);
|
||||
new DataView(buf).setBigInt64(0, BigInt(v), false);
|
||||
return new Uint8Array(buf);
|
||||
}
|
||||
function concat(...arrs) {
|
||||
let len = arrs.reduce((a, b) => a + b.length, 0);
|
||||
let out = new Uint8Array(len);
|
||||
let off = 0;
|
||||
for (let a of arrs) { out.set(a, off); off += a.length; }
|
||||
return out;
|
||||
}
|
||||
function textUtf8(s) {
|
||||
return new TextEncoder().encode(s);
|
||||
}
|
||||
|
||||
// === Построение HEADER ===
|
||||
function buildHeaderBody() {
|
||||
const tag = textUtf8("SHiNE001");
|
||||
const id = beLong(blockchainId);
|
||||
const login = textUtf8(userLogin);
|
||||
const loginLen = new Uint8Array([login.length]);
|
||||
const zeros = new Uint8Array(4+4+2+8+32); // type, num, ver, prev, pubkey
|
||||
return concat(tag, id, loginLen, login, zeros);
|
||||
}
|
||||
|
||||
function buildRawRecord(recordNumber, timestamp, recordType, recordTypeVersion, body) {
|
||||
const recordSize = 4+4+8+2+2+body.length;
|
||||
const buf = new ArrayBuffer(20);
|
||||
const view = new DataView(buf);
|
||||
view.setInt32(0, recordSize, false);
|
||||
view.setInt32(4, recordNumber, false);
|
||||
view.setBigInt64(8, BigInt(timestamp), false);
|
||||
view.setInt16(16, recordType, false);
|
||||
view.setInt16(18, recordTypeVersion, false);
|
||||
return concat(new Uint8Array(buf), body);
|
||||
}
|
||||
|
||||
// === Команды ===
|
||||
document.getElementById("btnConnect").onclick = () => {
|
||||
ws = new WebSocket(WS_URL);
|
||||
ws.binaryType = "arraybuffer";
|
||||
|
||||
ws.onopen = () => log("✅ Connected to " + WS_URL);
|
||||
ws.onclose = () => log("❌ Disconnected");
|
||||
ws.onerror = e => log("⚠️ Error: " + e.message);
|
||||
|
||||
ws.onmessage = e => {
|
||||
const data = new Uint8Array(e.data);
|
||||
const status = new DataView(data.buffer).getInt32(0, false);
|
||||
log("📩 Received status: " + status);
|
||||
if (data.length > 8) {
|
||||
const len = new DataView(data.buffer).getInt32(4, false);
|
||||
const payload = data.slice(8, 8 + len);
|
||||
log("Payload (" + len + " bytes): " + toHex(payload.slice(0, 64)) + "...");
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
document.getElementById("btnAddHeader").onclick = () => {
|
||||
if (!ws || ws.readyState !== WebSocket.OPEN) return log("⚠️ Not connected");
|
||||
const body = buildHeaderBody();
|
||||
const ts = Math.floor(Date.now() / 1000);
|
||||
const raw = buildRawRecord(0, ts, TYPE_HEADER, 1, body);
|
||||
const msg = concat(beInt(OP_ADD_BLOCK), beLong(blockchainId), raw);
|
||||
ws.send(msg);
|
||||
log("📤 Sent ADD_HEADER (" + raw.length + " bytes)");
|
||||
};
|
||||
|
||||
document.getElementById("btnGetChain").onclick = () => {
|
||||
if (!ws || ws.readyState !== WebSocket.OPEN) return log("⚠️ Not connected");
|
||||
const msg = concat(beInt(OP_GET_BLOCKCHAIN), beLong(blockchainId));
|
||||
ws.send(msg);
|
||||
log("📤 Sent GET_BLOCKCHAIN");
|
||||
};
|
||||
|
||||
document.getElementById("btnAddText").onclick = () => {
|
||||
if (!ws || ws.readyState !== WebSocket.OPEN) return log("⚠️ Not connected");
|
||||
const txt = document.getElementById("textInput").value.trim();
|
||||
if (!txt) return log("⚠️ Пустое сообщение");
|
||||
const body = textUtf8(txt);
|
||||
const ts = Math.floor(Date.now() / 1000);
|
||||
const raw = buildRawRecord(1, ts, TYPE_TEXT, 1, body);
|
||||
const msg = concat(beInt(OP_ADD_BLOCK), beLong(blockchainId), raw);
|
||||
ws.send(msg);
|
||||
log("📤 Sent ADD_TEXT (" + txt + ")");
|
||||
};
|
||||
|
||||
// === Helpers ===
|
||||
function toHex(buf) {
|
||||
return Array.from(buf).map(b => b.toString(16).padStart(2, "0")).join("");
|
||||
}
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
Loading…
Reference in New Issue
Block a user