Hedgehog_server
/
ServerMonitorBot
3
0
Fork 0
Code Issues 14 Pull Requests Packages Projects 1 Releases Wiki Activity

Merge pull request 'feature/task-38-roles' (#39) from feature/task-38-roles into master
Hedgehog_server_CD/ServerMonitorBot/pipeline/head This commit looks good Details 

Reviewed-on: #39
master
L_DelOff 2024-01-21 20:17:35 +03:00
parent bebf1b2916 a03a6abdfc
commit 23b5f02438
32 changed files with 515 additions and 492 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
docker-compose.yml
View File

@ -5,6 +5,7 @@ services:
context: .
depends_on:
- db
restart: always
networks:
default:
@ -14,6 +15,7 @@ services:
POSTGRES_USER: servermonitorbot
POSTGRES_PASSWORD: servermonitorbot
POSTGRES_DB: servermonitorbot
restart: always
networks:
default:

85
src/main/java/ru/ldeloff/servermonitorbot/controller/TelegramBotController.java
View File

@ -1,97 +1,42 @@
package ru.ldeloff.servermonitorbot.controller;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.telegram.telegrambots.bots.TelegramLongPollingBot;
import org.telegram.telegrambots.meta.api.objects.Message;
import org.telegram.telegrambots.meta.api.objects.Update;
import ru.ldeloff.servermonitorbot.model.TelegramBot;
import ru.ldeloff.servermonitorbot.repository.SshRepository;
import ru.ldeloff.servermonitorbot.service.command.FirstUseCommand;
import ru.ldeloff.servermonitorbot.service.command.GetStatusSessions;
import ru.ldeloff.servermonitorbot.service.command.CommandTemplate;
import ru.ldeloff.servermonitorbot.service.command.SwitchToMainMenu;
import ru.ldeloff.servermonitorbot.service.command.cputemp.CpuTempAggregateCommand;
import ru.ldeloff.servermonitorbot.service.command.cputemp.CpuTempCommand;
import ru.ldeloff.servermonitorbot.service.command.hddtemp.HddTempAggregateCommand;
import ru.ldeloff.servermonitorbot.service.command.hddtemp.HddTempCommand;
import ru.ldeloff.servermonitorbot.service.command.mdadm.MdadmStatusAggregateCommand;
import ru.ldeloff.servermonitorbot.service.command.mdadm.MdadmStatusCommand;
import ru.ldeloff.servermonitorbot.service.command.uname.UnameAggregateCommand;
import ru.ldeloff.servermonitorbot.service.command.uname.UnameCommand;
import java.util.Map;
@Service
@Slf4j
@RequiredArgsConstructor
public class TelegramBotController extends TelegramLongPollingBot {
private final Map<String, CommandTemplate> commands;
final TelegramBot telegramBot;
final SshRepository sshRepository;
final FirstUseCommand firstUseCommand;
final GetStatusSessions getStatusSessions;
final UnameAggregateCommand unameAggregateCommand;
final SwitchToMainMenu switchToMainMenu;
final UnameCommand unameCommand;
final CpuTempAggregateCommand cpuTempAggregateCommand;
final CpuTempCommand cpuTempCommand;
final HddTempAggregateCommand hddTempAggregateCommand;
final HddTempCommand hddTempCommand;
final MdadmStatusAggregateCommand mdadmStatusAggregateCommand;
final MdadmStatusCommand mdadmStatusCommand;
@Override
public void onUpdateReceived(Update update) {
if (update.hasMessage()) {
if (update.getMessage().hasText()) {
String messageText = update.getMessage().getText();
switch (messageText) {
case "/start" -> {
firstUseCommand.execute(update, this);
boolean result = false;
for (Map.Entry<String, CommandTemplate> entry : commands.entrySet()) {
result = entry.getValue().execute(update, this);
if (result) {
break;
}
case "Статус" -> {
getStatusSessions.execute(update, this);
}
case "uname" -> {
unameAggregateCommand.execute(update, this);
if (!result) {
Message message = update.getMessage();
if (message!=null) {
message.setText("Not found");
}
case "CPU.temp" -> {
cpuTempAggregateCommand.execute(update, this);
}
case "HDD.temp" -> {
hddTempAggregateCommand.execute(update, this);
}
case "MDADM" -> {
mdadmStatusAggregateCommand.execute(update,this);
}
default -> {
update.setMessage(message);
switchToMainMenu.execute(update, this);
}
}
}
} else if (update.hasCallbackQuery()) {
String [] tags = update.getCallbackQuery().getData().split(":");
if (tags.length > 1) {
switch (tags[0]) {
case "uname" -> {
unameCommand.execute(update, this);
}
case "CPU.temp" -> {
cpuTempCommand.execute(update, this);
}
case "HDD.temp" -> {
hddTempCommand.execute(update, this);
}
case "MDADM" -> {
mdadmStatusCommand.execute(update,this);
}
default -> {
switchToMainMenu.execute(update, this);
}
}
} else {
switchToMainMenu.execute(update, this);
}
}
}
@Override
public String getBotUsername() {
return telegramBot.getBotUsername();

7
src/main/java/ru/ldeloff/servermonitorbot/init/AddCommands.java Normal file
View File

@ -0,0 +1,7 @@
package ru.ldeloff.servermonitorbot.init;
public class AddCommands {
public static void fillCommandTable() {
}
}

23
src/main/java/ru/ldeloff/servermonitorbot/init/StartBot.java
View File

@ -7,30 +7,47 @@ import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;
import org.telegram.telegrambots.meta.TelegramBotsApi;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
import org.telegram.telegrambots.updatesreceivers.DefaultBotSession;
import ru.ldeloff.servermonitorbot.controller.TelegramBotController;
import ru.ldeloff.servermonitorbot.model.User;
import ru.ldeloff.servermonitorbot.service.command.CommandTemplate;
import ru.ldeloff.servermonitorbot.service.user.UserService;
import ru.ldeloff.servermonitorbot.utils.ui.TelegramBotKeyboard;
import static ru.ldeloff.servermonitorbot.init.AddCommands.fillCommandTable;
@Slf4j
@Component
@NoArgsConstructor
public class StartBot implements ApplicationRunner {
private TelegramBotController telegramBot;
private TelegramBotKeyboard telegramBotKeyboard;
private UserService userService;
@Autowired
public StartBot(TelegramBotController telegramBot) {
public StartBot(TelegramBotController telegramBot, TelegramBotKeyboard telegramBotKeyboard, UserService userService) {
this.telegramBot = telegramBot;
this.telegramBotKeyboard = telegramBotKeyboard;
this.userService = userService;
}
@Override
public void run(ApplicationArguments args) {
try {
fillCommandTable();
TelegramBotsApi botsApi = new TelegramBotsApi(DefaultBotSession.class);
botsApi.registerBot(telegramBot);
userService.getAllUsers().forEach(this::SendInitMessage);
log.info("Бот запущен");
} catch (TelegramApiException e) {
e.printStackTrace();
log.error(e.getMessage());
}
}
private void SendInitMessage(User user) {
SendMessage answer = new SendMessage();
answer.setChatId(user.getTelegramId());
answer.setText("Бот перезапущен");
CommandTemplate.sendMessage(telegramBotKeyboard.uiForm(answer), telegramBot);
}
}

28
src/main/java/ru/ldeloff/servermonitorbot/model/CommandList.java Normal file
View File

@ -0,0 +1,28 @@
package ru.ldeloff.servermonitorbot.model;
import jakarta.annotation.PostConstruct;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import ru.ldeloff.servermonitorbot.service.command.CommandTemplate;
import ru.ldeloff.servermonitorbot.utils.CommandUtil;
import java.util.HashMap;
import java.util.Map;
@Component
@RequiredArgsConstructor
public class CommandList {
private final Map<String, CommandTemplate> services;
@Getter
private HashMap<String, Long> commands;
@PostConstruct
private void setCommands() {
commands = new HashMap<>();
for (Map.Entry<String, CommandTemplate> entry : services.entrySet()) {
commands.put(entry.getValue().getName(), entry.getValue().getExpectedRole());
}
CommandUtil.setCommands(commands);
}
}

4
src/main/java/ru/ldeloff/servermonitorbot/model/Command.java → src/main/java/ru/ldeloff/servermonitorbot/model/SshCommand.java
View File

@ -7,7 +7,7 @@ import lombok.Setter;
@Getter
@Setter
public class Command {
public class SshCommand {
@NotNull
private String command;
@NotNull
@ -17,7 +17,7 @@ public class Command {
private SshServer sshServer;
private String response;
public Command(String command, int timeout, SshServer sshServer) {
public SshCommand(String command, int timeout, SshServer sshServer) {
this.command = command;
this.timeout = timeout;
this.sshServer = sshServer;

36
src/main/java/ru/ldeloff/servermonitorbot/repository/SshRepositoryImpl.java
View File

@ -5,14 +5,13 @@ import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Repository;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import ru.ldeloff.servermonitorbot.config.SshConfig;
import ru.ldeloff.servermonitorbot.model.SshServer;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.*;
@Slf4j
@Repository
@ -20,12 +19,15 @@ public class SshRepositoryImpl implements SshRepository {
private final List<SshServer> sshServers;
@Value("${ssh.timeout:5000}")
private int TIMEOUT;
@Autowired
public SshRepositoryImpl(SshConfig sshConfig) {
this.sshServers = sshConfig.getServers();
}
private List<Session> sessions = new ArrayList<>();
private Set<Session> sessions = new HashSet<>();
@Override
public void connectToAllServer() {
@ -34,7 +36,6 @@ public class SshRepositoryImpl implements SshRepository {
Session session = connectToServer(sshServer);
sshServer.setSession(session);
log.info("Успешно подключён к " + sshServer.getHost());
sessions.add(session);
} catch (JSchException e) {
log.warn("Не удалось соединиться с " + sshServer.getHost() + ": " + e.getMessage());
}
@ -48,7 +49,9 @@ public class SshRepositoryImpl implements SshRepository {
sshServer.getPort());
session.setPassword(sshServer.getPassword());
session.setConfig("StrictHostKeyChecking", "no");
session.setTimeout(TIMEOUT);
session.connect();
sessions.add(session);
return session;
}
@ -62,7 +65,7 @@ public class SshRepositoryImpl implements SshRepository {
@Override
public String getStatusSessions() {
StringBuilder text = new StringBuilder("Статус соединения: \n");
StringBuilder text = new StringBuilder("Статус соединения (может выполняться долго): \n");
sshServers.forEach(server -> {
text.append(server.getName())
.append(": ")
@ -79,10 +82,27 @@ public class SshRepositoryImpl implements SshRepository {
private String checkStatusServer(SshServer server) {
if (Objects.isNull(server.getSession())) {
try {
connectToServer(server);
return "OK";
} catch (JSchException e) {
log.warn("Не удалось соединиться с " + server.getHost() + ": " + e.getMessage());
return "нет соединения";
} else {
return server.getSession().isConnected() ? "OK" : "отключён";
}
}
if (server.getSession().isConnected()) {
return "OK";
} else {
try {
connectToServer(server);
return "OK";
} catch (JSchException e) {
log.warn("Не удалось соединиться с " + server.getHost() + ": " + e.getMessage());
return "потеряно соединение";
}
}
}
}

5
src/main/java/ru/ldeloff/servermonitorbot/repository/UserRepository.java
View File

@ -1,10 +1,15 @@
package ru.ldeloff.servermonitorbot.repository;
import jakarta.validation.constraints.NotNull;
import org.springframework.data.domain.Example;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import ru.ldeloff.servermonitorbot.model.User;
import java.util.List;
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
User getByTelegramId(long id);
@NotNull List<User> findAll();
}

147
src/main/java/ru/ldeloff/servermonitorbot/service/command/CommandTemplate.java
View File

@ -1,53 +1,158 @@
package ru.ldeloff.servermonitorbot.service.command;
import lombok.Data;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.Update;
import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
import ru.ldeloff.servermonitorbot.controller.TelegramBotController;
import ru.ldeloff.servermonitorbot.model.SshServer;
import ru.ldeloff.servermonitorbot.model.User;
import ru.ldeloff.servermonitorbot.service.role.RoleService;
import ru.ldeloff.servermonitorbot.service.ssh.SshService;
import ru.ldeloff.servermonitorbot.service.user.UserService;
import ru.ldeloff.servermonitorbot.utils.SshServerUtils;
import ru.ldeloff.servermonitorbot.utils.ui.ServerListButtons;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
@Data
@Slf4j
@RequiredArgsConstructor
public abstract class CommandTemplate {
final UserService userService;
final RoleService roleService;
long expectedRole = 2L;
public abstract SendMessage actionForAuth(User user, SendMessage message);
private final UserService userService;
private final RoleService roleService;
private final ServerListButtons serverListButtons;
private final SshService sshService;
@Getter
@Setter
private long expectedRole = 1L;
@Getter
@Setter
private String name;
public SendMessage actionForNotAuth(User user, SendMessage message) {
message.setText("У пользователя " + user.getLogin() + " (" + user.getTelegramId()
+ ") недостаточно прав для выполнения этой команды");
return message;
public boolean execute(Update update, TelegramBotController bot) {
if (!isExecute(update)) {
return false;
}
public void execute(Update update, TelegramBotController bot) {
User user = getUser(update);
String message = getMessage(update);
SendMessage answer = new SendMessage();
answer.setChatId(user.getTelegramId());
answer.setText(message);
if (user.getRole().getId() <= expectedRole) {
logSuccess(user, message);
sendMessage(actionForAuth(user, answer), bot);
} else {
if (!isAuth(update)) {
logNotAuth(user, message);
sendMessage(actionForNotAuth(user, answer), bot);
return true;
}
String type = checkTypeCommand(update);
switch (type) {
case "aggregate":
logSuccess(user, message);
sendMessage(executeAggregate(user, answer), bot);
return true;
case "command":
logSuccess(user, message);
sendMessage(executeCommand(user, answer), bot);
return true;
default:
return false;
}
}
protected void logSuccess(User user, String message) {
// Методы для проверки команды
private boolean isExecute(Update update) {
if (update.hasMessage()) {
if (update.getMessage().hasText()) {
String messageText = update.getMessage().getText();
if (Objects.equals(messageText, name)) {
log.debug("Команда " + messageText + " будет выполнена");
return true;
}
}
} else if (update.hasCallbackQuery()) {
String [] tags = update.getCallbackQuery().getData().split(":");
if (tags.length > 1) {
if (Objects.equals(tags[0], name)) {
log.debug("Команда " + tags[0] + " будет выполнена");
return true;
}
} else {
log.debug("Команда не будет выполнена");
return false;
}
}
log.debug("Команда не будет выполнена");
return false;
}
private String checkTypeCommand(Update update) {
if (update.hasMessage()) {
if (update.getMessage().hasText()) {
return "aggregate";
}
} else if (update.hasCallbackQuery()) {
String [] tags = update.getCallbackQuery().getData().split(":");
if (tags.length > 1) {
return "command";
} else {
return "error";
}
}
return "error";
}
private boolean isAuth(Update update) {
User user = getUser(update);
return user.getRole().getId() <= expectedRole;
}
// Методы при верных условиях
void logSuccess(User user, String message) {
log.info("Получена команда '" + message + "' от " + user.getLogin()
+ " (" + user.getTelegramId() + "). OK");
}
protected void logNotAuth(User user, String message) {
SendMessage executeAggregate(User user, SendMessage message) {
return serverListButtons.uiForm(message);
}
SendMessage executeCommand(User user, SendMessage message) {
String [] tags = Arrays.stream(message.getText().split(":"))
.map(String::trim)
.toArray(String[]::new);
if (tags[1].equals("all")) {
message.setText(executeCommandAllHost());
} else {
message.setText(Objects.requireNonNull(executeCommandSpecificHost(tags[1])));
}
return message;
}
private String executeCommandAllHost() {
List<SshServer> servers = SshServerUtils.filterGoodServers(sshService.getSshServers());
StringBuilder response = new StringBuilder();
servers.forEach(server -> response.append(executeCommandSpecificHost(server.getName())).append("\n"));
return response.toString();
}
public abstract String executeCommandSpecificHost(String serverName);
// Методы при неверных условиях
void logNotAuth(User user, String message) {
log.warn("Получена команда '" + message + "' от " + user.getLogin()
+ " (" + user.getTelegramId() + "). Нет прав");
}
private User getUser(Update update) {
private SendMessage actionForNotAuth(User user, SendMessage message) {
message.setText("У пользователя " + user.getLogin() + " (" + user.getTelegramId()
+ ") недостаточно прав для выполнения этой команды");
return message;
}
// Общее
// TODO: вынести в UpdateUtils
User getUser(Update update) {
long id = -1L;
String login = null;
if (update.hasMessage()) {
@ -66,8 +171,7 @@ public abstract class CommandTemplate {
user.setLogin(login);
return user;
}
private String getMessage(Update update) {
String getMessage(Update update) {
if (update.hasMessage()) {
return update.getMessage().getText();
} else if (update.hasCallbackQuery()) {
@ -76,7 +180,8 @@ public abstract class CommandTemplate {
return "";
}
private void sendMessage(SendMessage message, TelegramBotController bot) {
// TODO: вынести
public static void sendMessage(SendMessage message, TelegramBotController bot) {
try {
bot.execute(message);
} catch (TelegramApiException e) {

43
src/main/java/ru/ldeloff/servermonitorbot/service/command/CpuTempCommand.java Normal file
View File

@ -0,0 +1,43 @@
package ru.ldeloff.servermonitorbot.service.command;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import ru.ldeloff.servermonitorbot.model.SshCommand;
import ru.ldeloff.servermonitorbot.model.SshServer;
import ru.ldeloff.servermonitorbot.service.role.RoleService;
import ru.ldeloff.servermonitorbot.service.ssh.SshService;
import ru.ldeloff.servermonitorbot.service.user.UserService;
import ru.ldeloff.servermonitorbot.utils.ui.ServerListButtons;
import java.util.Objects;
import java.util.Optional;
@Service
@Slf4j
public class CpuTempCommand extends CommandTemplate {
final SshService sshService;
public CpuTempCommand(UserService userService, RoleService roleService, SshService sshService, ServerListButtons serverListButtons) {
super(userService, roleService, serverListButtons, sshService);
this.sshService = sshService;
setName("CPU.temp");
}
@Override
public String executeCommandSpecificHost(String serverName) {
Optional<SshServer> server = sshService.getSshServers()
.stream()
.filter(x -> x.getName().equals(serverName))
.findFirst();
if (server.isPresent()) {
SshCommand result = sshService.execute(new SshCommand("cat /sys/class/thermal/thermal_zone0/temp", 100, server.get()));
return server.get().getName() + ": \n" +
(Objects.isNull(result.getResponse()) ? "ошибка при выполнении команды" :
String.format("%.1f",
Double.parseDouble(result.getResponse().replaceAll("\n", ""))/1000))
+ "°C";
} else {
log.error("Ошибка при выполнении команды 'CPUtemp'. Искомый сервер (" + serverName + ") не найден");
return null;
}
}
}

20
src/main/java/ru/ldeloff/servermonitorbot/service/command/FirstUseCommand.java
View File

@ -2,22 +2,36 @@ package ru.ldeloff.servermonitorbot.service.command;
import org.springframework.stereotype.Service;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.Update;
import ru.ldeloff.servermonitorbot.model.User;
import ru.ldeloff.servermonitorbot.service.role.RoleService;
import ru.ldeloff.servermonitorbot.service.ssh.SshService;
import ru.ldeloff.servermonitorbot.service.user.UserService;
import ru.ldeloff.servermonitorbot.utils.ui.ServerListButtons;
import ru.ldeloff.servermonitorbot.utils.ui.TelegramBotKeyboard;
@Service
public class FirstUseCommand extends CommandTemplate {
final TelegramBotKeyboard telegramBotKeyboard;
public FirstUseCommand(UserService userService, RoleService roleService, TelegramBotKeyboard telegramBotKeyboard) {
super(userService, roleService);
public FirstUseCommand(UserService userService,
RoleService roleService,
SshService sshService,
ServerListButtons serverListButtons,
TelegramBotKeyboard telegramBotKeyboard) {
super(userService, roleService, serverListButtons, sshService);
this.telegramBotKeyboard = telegramBotKeyboard;
setName("/start");
}
@Override
public SendMessage actionForAuth(User user, SendMessage message) {
public SendMessage executeAggregate(User user, SendMessage message) {
message.setText("Добро пожаловать " + user.getLogin() + "!");
return telegramBotKeyboard.uiForm(message);
}
@Override
public String executeCommandSpecificHost(String serverName) {
return null;
}
}

14
src/main/java/ru/ldeloff/servermonitorbot/service/command/GetStatusSessions.java
View File

@ -6,18 +6,22 @@ import ru.ldeloff.servermonitorbot.model.User;
import ru.ldeloff.servermonitorbot.service.role.RoleService;
import ru.ldeloff.servermonitorbot.service.ssh.SshService;
import ru.ldeloff.servermonitorbot.service.user.UserService;
import ru.ldeloff.servermonitorbot.utils.ui.ServerListButtons;
@Service
public class GetStatusSessions extends CommandTemplate {
final SshService sshService;
public GetStatusSessions(UserService userService, RoleService roleService, SshService sshService) {
super(userService, roleService);
public GetStatusSessions(UserService userService, RoleService roleService, SshService sshService, ServerListButtons serverListButtons) {
super(userService, roleService, serverListButtons, sshService);
this.sshService = sshService;
setName("Статус");
}
@Override
public SendMessage actionForAuth(User user, SendMessage message) {
public SendMessage executeAggregate(User user, SendMessage message) {
return sshService.getStatusSessions(message);
}
@Override
public String executeCommandSpecificHost(String serverName) {
return null;
}
}

39
src/main/java/ru/ldeloff/servermonitorbot/service/command/HddTempCommand.java Normal file
View File

@ -0,0 +1,39 @@
package ru.ldeloff.servermonitorbot.service.command;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import ru.ldeloff.servermonitorbot.model.SshCommand;
import ru.ldeloff.servermonitorbot.model.SshServer;
import ru.ldeloff.servermonitorbot.service.role.RoleService;
import ru.ldeloff.servermonitorbot.service.ssh.SshService;
import ru.ldeloff.servermonitorbot.service.user.UserService;
import ru.ldeloff.servermonitorbot.utils.ui.ServerListButtons;
import java.util.Objects;
import java.util.Optional;
@Service
@Slf4j
public class HddTempCommand extends CommandTemplate {
final SshService sshService;
public HddTempCommand(UserService userService, RoleService roleService, SshService sshService, ServerListButtons serverListButtons) {
super(userService, roleService, serverListButtons, sshService);
this.sshService = sshService;
setName("HDD.temp");
}
@Override
public String executeCommandSpecificHost(String serverName) {
Optional<SshServer> server = sshService.getSshServers()
.stream()
.filter(x -> x.getName().equals(serverName))
.findFirst();
if (server.isPresent()) {
SshCommand result = sshService.execute(new SshCommand("hddtemp /dev/sd*", 500, server.get()));
return server.get().getName() + ": \n" +
(Objects.isNull(result.getResponse()) ? "ошибка при выполнении команды" : result.getResponse());
} else {
log.error("Ошибка при выполнении команды 'hddtemp'. Искомый сервер (" + serverName + ") не найден");
return null;
}
}
}

55
src/main/java/ru/ldeloff/servermonitorbot/service/command/mdadm/MdadmStatusCommand.java → src/main/java/ru/ldeloff/servermonitorbot/service/command/MdadmStatusCommand.java
View File

@ -1,69 +1,41 @@
package ru.ldeloff.servermonitorbot.service.command.mdadm;
package ru.ldeloff.servermonitorbot.service.command;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import ru.ldeloff.servermonitorbot.model.Command;
import ru.ldeloff.servermonitorbot.model.SshCommand;
import ru.ldeloff.servermonitorbot.model.SshServer;
import ru.ldeloff.servermonitorbot.model.User;
import ru.ldeloff.servermonitorbot.service.command.CommandTemplate;
import ru.ldeloff.servermonitorbot.service.role.RoleService;
import ru.ldeloff.servermonitorbot.service.ssh.SshService;
import ru.ldeloff.servermonitorbot.service.user.UserService;
import ru.ldeloff.servermonitorbot.utils.SshServerUtils;
import ru.ldeloff.servermonitorbot.utils.ui.ServerListButtons;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
@Service
@Slf4j
public class MdadmStatusCommand extends CommandTemplate {
final SshService sshService;
public MdadmStatusCommand(UserService userService, RoleService roleService, SshService sshService) {
super(userService, roleService);
public MdadmStatusCommand(UserService userService, RoleService roleService, SshService sshService, ServerListButtons serverListButtons) {
super(userService, roleService, serverListButtons, sshService);
this.sshService = sshService;
setName("MDADM");
}
@Override
public SendMessage actionForAuth(User user, SendMessage message) {
String [] tags = Arrays.stream(message.getText().split(":"))
.map(String::trim)
.toArray(String[]::new);
if (tags[1].equals("all")) {
message.setText(mdadmStatusAllHost());
} else {
message.setText(Objects.requireNonNull(mdadmStatusSpecificHost(tags[1])));
}
return message;
}
private String mdadmStatusAllHost() {
List<SshServer> servers = SshServerUtils.filterGoodServers(sshService.getSshServers());
StringBuilder response = new StringBuilder();
servers.forEach(server -> response.append(mdadmStatusSpecificHost(server.getName())).append("\n"));
return response.toString();
}
private String mdadmStatusSpecificHost(String serverName) {
public String executeCommandSpecificHost(String serverName) {
Optional<SshServer> server = sshService.getSshServers()
.stream()
.filter(x -> x.getName().equals(serverName))
.findFirst();
if (server.isPresent()) {
// узнаю скок рейдов
Command commandRaid = sshService.execute(new Command("mdadm --detail --scan", 500, server.get()));
List<String> raidNames = parseRaidNames(commandRaid);
SshCommand sshCommandRaid = sshService.execute(new SshCommand("mdadm --detail --scan", 500, server.get()));
List<String> raidNames = parseRaidNames(sshCommandRaid);
// Для каждого рейда надо выяснить статус
StringBuilder result = new StringBuilder();
raidNames.forEach(raid -> {
result.append(raid).append(":\n");
Command commandHdd = sshService.execute(new Command("mdadm --detail " + raid, 500, server.get()));
List<String> hdds = parseHddState(commandHdd);
SshCommand sshCommandHdd = sshService.execute(new SshCommand("mdadm --detail " + raid, 500, server.get()));
List<String> hdds = parseHddState(sshCommandHdd);
hdds.forEach(hdd -> result.append(hdd).append("\n"));
});
return server.get().getName() + ": \n" + result;
@ -72,7 +44,7 @@ public class MdadmStatusCommand extends CommandTemplate {
return null;
}
}
private List<String> parseRaidNames(Command result) {
private List<String> parseRaidNames(SshCommand result) {
List<String> names = new ArrayList<>();
Arrays.stream(result.getResponse().split("\n"))
.map(line -> line.split(" "))
@ -81,8 +53,7 @@ public class MdadmStatusCommand extends CommandTemplate {
.forEach(names::add);
return names;
}
private List<String> parseHddState(Command result) {
private List<String> parseHddState(SshCommand result) {
List<String> names = new ArrayList<>();
names.add("Number Name State");

30
src/main/java/ru/ldeloff/servermonitorbot/service/command/SwitchToMainMenu.java
View File

@ -3,9 +3,13 @@ package ru.ldeloff.servermonitorbot.service.command;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.Update;
import ru.ldeloff.servermonitorbot.controller.TelegramBotController;
import ru.ldeloff.servermonitorbot.model.User;
import ru.ldeloff.servermonitorbot.service.role.RoleService;
import ru.ldeloff.servermonitorbot.service.ssh.SshService;
import ru.ldeloff.servermonitorbot.service.user.UserService;
import ru.ldeloff.servermonitorbot.utils.ui.ServerListButtons;
import ru.ldeloff.servermonitorbot.utils.ui.TelegramBotKeyboard;
@Service
@ -13,23 +17,31 @@ import ru.ldeloff.servermonitorbot.utils.ui.TelegramBotKeyboard;
public class SwitchToMainMenu extends CommandTemplate {
final TelegramBotKeyboard telegramBotKeyboard;
public SwitchToMainMenu(UserService userService, RoleService roleService, TelegramBotKeyboard telegramBotKeyboard) {
super(userService, roleService);
public SwitchToMainMenu(UserService userService,
RoleService roleService,
SshService sshService,
ServerListButtons serverListButtons,
TelegramBotKeyboard telegramBotKeyboard) {
super(userService, roleService, serverListButtons, sshService);
this.telegramBotKeyboard = telegramBotKeyboard;
setName("Not found");
}
@Override
public SendMessage actionForAuth(User user, SendMessage message) {
message.setText("Неверная команда. Попробуем сначала.");
return telegramBotKeyboard.uiForm(message);
public String executeCommandSpecificHost(String serverName) {
return null;
}
@Override
public void logSuccess(User user, String message) {
void logSuccess(User user, String message) {
log.warn("Получена несуществующая команда '" + message + "' от " + user.getLogin()
+ " (" + user.getTelegramId() + "). OK");
}
@Override
public void logNotAuth(User user, String message) {
log.warn("Получена несуществующая команда '" + message + "' от " + user.getLogin()
+ " (" + user.getTelegramId() + "). Нет прав");
SendMessage executeAggregate(User user, SendMessage message) {
SendMessage answer = new SendMessage();
answer.setChatId(user.getTelegramId());
answer.setText("Неверная команда. Попробуем сначала.");
return telegramBotKeyboard.uiForm(answer);
}
}

39
src/main/java/ru/ldeloff/servermonitorbot/service/command/UnameCommand.java Normal file
View File

@ -0,0 +1,39 @@
package ru.ldeloff.servermonitorbot.service.command;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import ru.ldeloff.servermonitorbot.model.SshCommand;
import ru.ldeloff.servermonitorbot.model.SshServer;
import ru.ldeloff.servermonitorbot.service.role.RoleService;
import ru.ldeloff.servermonitorbot.service.ssh.SshService;
import ru.ldeloff.servermonitorbot.service.user.UserService;
import ru.ldeloff.servermonitorbot.utils.ui.ServerListButtons;
import java.util.Objects;
import java.util.Optional;
@Service
@Slf4j
public class UnameCommand extends CommandTemplate {
final SshService sshService;
public UnameCommand(UserService userService, RoleService roleService, SshService sshService, ServerListButtons serverListButtons) {
super(userService, roleService, serverListButtons, sshService);
this.sshService = sshService;
setName("uname");
}
@Override
public String executeCommandSpecificHost(String serverName) {
Optional<SshServer> server = sshService.getSshServers()
.stream()
.filter(x -> x.getName().equals(serverName))
.findFirst();
if (server.isPresent()) {
SshCommand result = sshService.execute(new SshCommand("uname -a", 100, server.get()));
return server.get().getName() + ": " +
(Objects.isNull(result.getResponse()) ? "ошибка при выполнении команды" : result.getResponse());
} else {
log.error("Ошибка при выполнении команды 'uname'. Искомый сервер (" + serverName + ") не найден");
return null;
}
}
}

24
src/main/java/ru/ldeloff/servermonitorbot/service/command/cputemp/CpuTempAggregateCommand.java
View File

@ -1,24 +0,0 @@
package ru.ldeloff.servermonitorbot.service.command.cputemp;
import org.springframework.stereotype.Service;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import ru.ldeloff.servermonitorbot.model.User;
import ru.ldeloff.servermonitorbot.service.command.CommandTemplate;
import ru.ldeloff.servermonitorbot.service.role.RoleService;
import ru.ldeloff.servermonitorbot.service.user.UserService;
import ru.ldeloff.servermonitorbot.utils.ui.uname.ServerListButtons;
@Service
public class CpuTempAggregateCommand extends CommandTemplate {
final ServerListButtons serverListButtons;
public CpuTempAggregateCommand(UserService userService, RoleService roleService, ServerListButtons serverListButtons) {
super(userService, roleService);
this.serverListButtons = serverListButtons;
}
@Override
public SendMessage actionForAuth(User user, SendMessage message) {
return serverListButtons.uiForm(message);
}
}

67
src/main/java/ru/ldeloff/servermonitorbot/service/command/cputemp/CpuTempCommand.java
View File

@ -1,67 +0,0 @@
package ru.ldeloff.servermonitorbot.service.command.cputemp;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import ru.ldeloff.servermonitorbot.model.Command;
import ru.ldeloff.servermonitorbot.model.SshServer;
import ru.ldeloff.servermonitorbot.model.User;
import ru.ldeloff.servermonitorbot.service.command.CommandTemplate;
import ru.ldeloff.servermonitorbot.service.role.RoleService;
import ru.ldeloff.servermonitorbot.service.ssh.SshService;
import ru.ldeloff.servermonitorbot.service.user.UserService;
import ru.ldeloff.servermonitorbot.utils.SshServerUtils;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
@Service
@Slf4j
public class CpuTempCommand extends CommandTemplate {
final SshService sshService;
public CpuTempCommand(UserService userService, RoleService roleService, SshService sshService) {
super(userService, roleService);
this.sshService = sshService;
}
@Override
public SendMessage actionForAuth(User user, SendMessage message) {
String [] tags = Arrays.stream(message.getText().split(":"))
.map(String::trim)
.toArray(String[]::new);
if (tags[1].equals("all")) {
message.setText(hddTempAllHost());
} else {
message.setText(Objects.requireNonNull(hddTempSpecificHost(tags[1])));
}
return message;
}
private String hddTempAllHost() {
List<SshServer> servers = SshServerUtils.filterGoodServers(sshService.getSshServers());
StringBuilder response = new StringBuilder();
servers.forEach(server -> response.append(hddTempSpecificHost(server.getName())).append("\n"));
return response.toString();
}
private String hddTempSpecificHost(String serverName) {
Optional<SshServer> server = sshService.getSshServers()
.stream()
.filter(x -> x.getName().equals(serverName))
.findFirst();
if (server.isPresent()) {
Command result = sshService.execute(new Command("cat /sys/class/thermal/thermal_zone0/temp", 100, server.get()));
return server.get().getName() + ": \n" +
(Objects.isNull(result.getResponse()) ? "ошибка при выполнении команды" :
String.format("%.1f",
Double.parseDouble(result.getResponse().replaceAll("\n", ""))/1000))
+ "°C";
} else {
log.error("Ошибка при выполнении команды 'CPUtemp'. Искомый сервер (" + serverName + ") не найден");
return null;
}
}
}

24
src/main/java/ru/ldeloff/servermonitorbot/service/command/hddtemp/HddTempAggregateCommand.java
View File

@ -1,24 +0,0 @@
package ru.ldeloff.servermonitorbot.service.command.hddtemp;
import org.springframework.stereotype.Service;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import ru.ldeloff.servermonitorbot.model.User;
import ru.ldeloff.servermonitorbot.service.command.CommandTemplate;
import ru.ldeloff.servermonitorbot.service.role.RoleService;
import ru.ldeloff.servermonitorbot.service.user.UserService;
import ru.ldeloff.servermonitorbot.utils.ui.uname.ServerListButtons;
@Service
public class HddTempAggregateCommand extends CommandTemplate {
final ServerListButtons serverListButtons;
public HddTempAggregateCommand(UserService userService, RoleService roleService, ServerListButtons serverListButtons) {
super(userService, roleService);
this.serverListButtons = serverListButtons;
}
@Override
public SendMessage actionForAuth(User user, SendMessage message) {
return serverListButtons.uiForm(message);
}
}

64
src/main/java/ru/ldeloff/servermonitorbot/service/command/hddtemp/HddTempCommand.java
View File

@ -1,64 +0,0 @@
package ru.ldeloff.servermonitorbot.service.command.hddtemp;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import ru.ldeloff.servermonitorbot.model.Command;
import ru.ldeloff.servermonitorbot.model.SshServer;
import ru.ldeloff.servermonitorbot.model.User;
import ru.ldeloff.servermonitorbot.service.command.CommandTemplate;
import ru.ldeloff.servermonitorbot.service.role.RoleService;
import ru.ldeloff.servermonitorbot.service.ssh.SshService;
import ru.ldeloff.servermonitorbot.service.user.UserService;
import ru.ldeloff.servermonitorbot.utils.SshServerUtils;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
@Service
@Slf4j
public class HddTempCommand extends CommandTemplate {
final SshService sshService;
public HddTempCommand(UserService userService, RoleService roleService, SshService sshService) {
super(userService, roleService);
this.sshService = sshService;
}
@Override
public SendMessage actionForAuth(User user, SendMessage message) {
String [] tags = Arrays.stream(message.getText().split(":"))
.map(String::trim)
.toArray(String[]::new);
if (tags[1].equals("all")) {
message.setText(hddTempAllHost());
} else {
message.setText(Objects.requireNonNull(hddTempSpecificHost(tags[1])));
}
return message;
}
private String hddTempAllHost() {
List<SshServer> servers = SshServerUtils.filterGoodServers(sshService.getSshServers());
StringBuilder response = new StringBuilder();
servers.forEach(server -> response.append(hddTempSpecificHost(server.getName())).append("\n"));
return response.toString();
}
private String hddTempSpecificHost(String serverName) {
Optional<SshServer> server = sshService.getSshServers()
.stream()
.filter(x -> x.getName().equals(serverName))
.findFirst();
if (server.isPresent()) {
Command result = sshService.execute(new Command("hddtemp /dev/sd*", 500, server.get()));
return server.get().getName() + ": \n" +
(Objects.isNull(result.getResponse()) ? "ошибка при выполнении команды" : result.getResponse());
} else {
log.error("Ошибка при выполнении команды 'hddtemp'. Искомый сервер (" + serverName + ") не найден");
return null;
}
}
}

25
src/main/java/ru/ldeloff/servermonitorbot/service/command/mdadm/MdadmStatusAggregateCommand.java
View File

@ -1,25 +0,0 @@
package ru.ldeloff.servermonitorbot.service.command.mdadm;
import org.springframework.stereotype.Service;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import ru.ldeloff.servermonitorbot.model.User;
import ru.ldeloff.servermonitorbot.service.command.CommandTemplate;
import ru.ldeloff.servermonitorbot.service.role.RoleService;
import ru.ldeloff.servermonitorbot.service.user.UserService;
import ru.ldeloff.servermonitorbot.utils.ui.uname.ServerListButtons;
@Service
public class MdadmStatusAggregateCommand extends CommandTemplate {
final ServerListButtons serverListButtons;
public MdadmStatusAggregateCommand(UserService userService, RoleService roleService, ServerListButtons serverListButtons) {
super(userService, roleService);
this.serverListButtons = serverListButtons;
}
@Override
public SendMessage actionForAuth(User user, SendMessage message) {
return serverListButtons.uiForm(message);
}
}

24
src/main/java/ru/ldeloff/servermonitorbot/service/command/uname/UnameAggregateCommand.java
View File

@ -1,24 +0,0 @@
package ru.ldeloff.servermonitorbot.service.command.uname;
import org.springframework.stereotype.Service;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import ru.ldeloff.servermonitorbot.model.User;
import ru.ldeloff.servermonitorbot.service.command.CommandTemplate;
import ru.ldeloff.servermonitorbot.service.role.RoleService;
import ru.ldeloff.servermonitorbot.service.user.UserService;
import ru.ldeloff.servermonitorbot.utils.ui.uname.ServerListButtons;
@Service
public class UnameAggregateCommand extends CommandTemplate {
final ServerListButtons serverListButtons;
public UnameAggregateCommand(UserService userService, RoleService roleService, ServerListButtons serverListButtons) {
super(userService, roleService);
this.serverListButtons = serverListButtons;
}
@Override
public SendMessage actionForAuth(User user, SendMessage message) {
return serverListButtons.uiForm(message);
}
}

63
src/main/java/ru/ldeloff/servermonitorbot/service/command/uname/UnameCommand.java
View File

@ -1,63 +0,0 @@
package ru.ldeloff.servermonitorbot.service.command.uname;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import ru.ldeloff.servermonitorbot.model.Command;
import ru.ldeloff.servermonitorbot.model.SshServer;
import ru.ldeloff.servermonitorbot.model.User;
import ru.ldeloff.servermonitorbot.service.command.CommandTemplate;
import ru.ldeloff.servermonitorbot.service.role.RoleService;
import ru.ldeloff.servermonitorbot.service.ssh.SshService;
import ru.ldeloff.servermonitorbot.service.user.UserService;
import ru.ldeloff.servermonitorbot.utils.SshServerUtils;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
@Service
@Slf4j
public class UnameCommand extends CommandTemplate {
final SshService sshService;
public UnameCommand(UserService userService, RoleService roleService, SshService sshService) {
super(userService, roleService);
this.sshService = sshService;
}
@Override
public SendMessage actionForAuth(User user, SendMessage message) {
String [] tags = Arrays.stream(message.getText().split(":"))
.map(String::trim)
.toArray(String[]::new);
if (tags[1].equals("all")) {
message.setText(unameAllHost());
} else {
message.setText(Objects.requireNonNull(unameSpecificHost(tags[1])));
}
return message;
}
private String unameAllHost() {
List<SshServer> servers = SshServerUtils.filterGoodServers(sshService.getSshServers());
StringBuilder response = new StringBuilder();
servers.forEach(server -> response.append(unameSpecificHost(server.getName())).append("\n"));
return response.toString();
}
private String unameSpecificHost(String serverName) {
Optional<SshServer> server = sshService.getSshServers()
.stream()
.filter(x -> x.getName().equals(serverName))
.findFirst();
if (server.isPresent()) {
Command result = sshService.execute(new Command("uname -a", 100, server.get()));
return server.get().getName() + ": " +
(Objects.isNull(result.getResponse()) ? "ошибка при выполнении команды" : result.getResponse());
} else {
log.error("Ошибка при выполнении команды 'uname'. Искомый сервер (" + serverName + ") не найден");
return null;
}
}
}

6
src/main/java/ru/ldeloff/servermonitorbot/service/ssh/SshService.java
View File

@ -2,7 +2,7 @@ package ru.ldeloff.servermonitorbot.service.ssh;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import ru.ldeloff.servermonitorbot.model.Command;
import ru.ldeloff.servermonitorbot.model.SshCommand;
import ru.ldeloff.servermonitorbot.model.SshServer;
import java.util.List;
@ -11,6 +11,6 @@ public interface SshService {
SendMessage getStatusSessions(SendMessage update);
List<SshServer> getSshServers();
Command execute(Command command);
List<Command> execute(List<Command> commands);
SshCommand execute(SshCommand sshCommand);
List<SshCommand> execute(List<SshCommand> sshCommands);
}

18
src/main/java/ru/ldeloff/servermonitorbot/service/ssh/SshServiceImpl.java
View File

@ -7,7 +7,7 @@ import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import ru.ldeloff.servermonitorbot.model.Command;
import ru.ldeloff.servermonitorbot.model.SshCommand;
import ru.ldeloff.servermonitorbot.model.SshServer;
import ru.ldeloff.servermonitorbot.repository.SshRepository;
@ -31,21 +31,21 @@ public class SshServiceImpl implements SshService {
}
@Override
public Command execute(Command command) {
List<Command> commands = new ArrayList<>();
commands.add(command);
return execute(commands).get(0);
public SshCommand execute(SshCommand sshCommand) {
List<SshCommand> sshCommands = new ArrayList<>();
sshCommands.add(sshCommand);
return execute(sshCommands).get(0);
}
@Override
public List<Command> execute(List<Command> commands) {
Session session = commands.get(0).getSshServer().getSession(); // подразумевается, что в листе с командами сервер один и тот же
public List<SshCommand> execute(List<SshCommand> sshCommands) {
Session session = sshCommands.get(0).getSshServer().getSession(); // подразумевается, что в листе с командами сервер один и тот же
ChannelExec channel = null;
try {
channel = (ChannelExec) session.openChannel("exec");
ChannelExec finalChannel = channel;
commands.forEach(command -> {
sshCommands.forEach(command -> {
try {
finalChannel.setCommand(command.getCommand());
ByteArrayOutputStream responseStream = new ByteArrayOutputStream();
@ -69,6 +69,6 @@ public class SshServiceImpl implements SshService {
channel.disconnect();
}
}
return commands;
return sshCommands;
}
}

4
src/main/java/ru/ldeloff/servermonitorbot/service/user/UserService.java
View File

@ -2,8 +2,12 @@ package ru.ldeloff.servermonitorbot.service.user;
import ru.ldeloff.servermonitorbot.model.User;
import java.util.List;
public interface UserService {
User saveOrUpdateUser(User user);
User getByTelegramId(Long id);
List<User> getAllUsers();
}

5
src/main/java/ru/ldeloff/servermonitorbot/service/user/UserServiceImpl.java
View File

@ -6,6 +6,8 @@ import org.springframework.stereotype.Service;
import ru.ldeloff.servermonitorbot.model.User;
import ru.ldeloff.servermonitorbot.repository.UserRepository;
import java.util.List;
@Service
@RequiredArgsConstructor
@Slf4j
@ -26,4 +28,7 @@ public class UserServiceImpl implements UserService {
public User getByTelegramId(Long id) {
return userRepository.getByTelegramId(id);
}
@Override
public List<User> getAllUsers() {return userRepository.findAll(); }
}

15
src/main/java/ru/ldeloff/servermonitorbot/utils/CommandUtil.java Normal file
View File

@ -0,0 +1,15 @@
package ru.ldeloff.servermonitorbot.utils;
import lombok.Getter;
import lombok.Setter;
import lombok.experimental.UtilityClass;
import java.util.HashMap;
@UtilityClass
public class CommandUtil {
@Setter
@Getter
private HashMap<String, Long> commands;
}

19
src/main/java/ru/ldeloff/servermonitorbot/utils/RoleChecker.java Normal file
View File

@ -0,0 +1,19 @@
package ru.ldeloff.servermonitorbot.utils;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import ru.ldeloff.servermonitorbot.model.Role;
import ru.ldeloff.servermonitorbot.model.User;
import ru.ldeloff.servermonitorbot.service.user.UserService;
@RequiredArgsConstructor
@Component
public class RoleChecker {
final UserService userService;
public Role getRole(SendMessage sendMessage) {
String chatId = sendMessage.getChatId();
User user = userService.getByTelegramId(Long.parseLong(chatId));
return user.getRole();
}
}

5
src/main/java/ru/ldeloff/servermonitorbot/utils/ui/uname/ServerListButtons.java → src/main/java/ru/ldeloff/servermonitorbot/utils/ui/ServerListButtons.java
View File

@ -1,11 +1,13 @@
package ru.ldeloff.servermonitorbot.utils.ui.uname;
package ru.ldeloff.servermonitorbot.utils.ui;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.InlineKeyboardMarkup;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.InlineKeyboardButton;
import ru.ldeloff.servermonitorbot.model.Role;
import ru.ldeloff.servermonitorbot.service.ssh.SshService;
import ru.ldeloff.servermonitorbot.utils.RoleChecker;
import ru.ldeloff.servermonitorbot.utils.ui.UiFormer;
import java.util.ArrayList;
@ -21,7 +23,6 @@ public class ServerListButtons implements UiFormer {
@Override
public SendMessage uiForm(SendMessage message) {
List<List<InlineKeyboardButton>> keyboard = new ArrayList<>();
InlineKeyboardMarkup inlineKeyboardMarkup = new InlineKeyboardMarkup();
sshService.getSshServers().forEach(sshServer -> {

58
src/main/java/ru/ldeloff/servermonitorbot/utils/ui/TelegramBotKeyboard.java
View File

@ -1,45 +1,63 @@
package ru.ldeloff.servermonitorbot.utils.ui;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.ReplyKeyboardMarkup;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.KeyboardButton;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.KeyboardRow;
import ru.ldeloff.servermonitorbot.model.CommandList;
import ru.ldeloff.servermonitorbot.model.Role;
import ru.ldeloff.servermonitorbot.service.command.CommandTemplate;
import ru.ldeloff.servermonitorbot.utils.CommandUtil;
import ru.ldeloff.servermonitorbot.utils.RoleChecker;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
@Component
@RequiredArgsConstructor
public class TelegramBotKeyboard implements UiFormer {
private final String STATUS = "Статус";
private final String UNAME = "uname";
private final String CPU_TEMP = "CPU.temp";
private final String HDD_TEMP = "HDD.temp";
private final String MDADM = "MDADM";
private final RoleChecker roleChecker;
@Override
public SendMessage uiForm(SendMessage message) {
ReplyKeyboardMarkup replyKeyboardMarkup = new ReplyKeyboardMarkup();
replyKeyboardMarkup.setResizeKeyboard(true);
replyKeyboardMarkup.setOneTimeKeyboard(false);
ArrayList<KeyboardRow> keyboardRows = new ArrayList<>();
KeyboardRow keyboardRow1 = new KeyboardRow();
keyboardRows.add(keyboardRow1);
keyboardRow1.add(new KeyboardButton(STATUS));
keyboardRow1.add(new KeyboardButton(UNAME));
keyboardRow1.add(new KeyboardButton(CPU_TEMP));
keyboardRow1.add(new KeyboardButton(HDD_TEMP));
KeyboardRow keyboardRow2 = new KeyboardRow();
keyboardRows.add(keyboardRow2);
keyboardRow2.add(new KeyboardButton(MDADM));
ArrayList<KeyboardRow> keyboardRows = formKeyboard(
roleChecker.getRole(message).getId());
replyKeyboardMarkup.setKeyboard(keyboardRows);
message.setReplyMarkup(replyKeyboardMarkup);
return message;
}
private ArrayList<KeyboardRow> formKeyboard(long role) {
HashMap<String, Long> commands = CommandUtil.getCommands();
if (role < 3) {
commands.remove("/start");
commands.remove("Not found");
}
int buttonOnLine = 3;
ArrayList<KeyboardRow> keyboardRows = new ArrayList<>();
KeyboardRow keyboardRow = new KeyboardRow();
for (Map.Entry<String, Long> entry : commands.entrySet()) {
if (role <= entry.getValue()) {
keyboardRow.add(new KeyboardButton(entry.getKey()));
}
if (keyboardRow.size()>=buttonOnLine) {
keyboardRows.add(keyboardRow);
keyboardRow = new KeyboardRow();
}
}
if (keyboardRow.size() > 0) {
keyboardRows.add(keyboardRow);
}
return keyboardRows;
}
}

1
src/main/resources/application.yml
View File

@ -17,6 +17,7 @@ bot:
- telegramId: 123456789
role: admin
ssh:
timeout: 5000
servers:
-
name: "Server Name"