тест коммита

Reviewed-on: L_DelOff/ServerMonitorBot#28

pom.xml

@@ -42,8 +42,23 @@
             <artifactId>telegrambots</artifactId>
             <version>6.7.0</version>
         </dependency>
-
+        <dependency>
-
+            <groupId>com.jcraft</groupId>
+            <artifactId>jsch</artifactId>
+            <version>0.1.55</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-jpa</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.liquibase</groupId>
+            <artifactId>liquibase-core</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.postgresql</groupId>
+            <artifactId>postgresql</artifactId>
+        </dependency>
     </dependencies>
 
     <build>

src/main/java/ru/ldeloff/servermonitorbot/ServerMonitorBotApplication.java

@@ -2,8 +2,11 @@ package ru.ldeloff.servermonitorbot;
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import ru.ldeloff.servermonitorbot.config.SshConfig;
 
 @SpringBootApplication
+@EnableConfigurationProperties(SshConfig.class)
 public class ServerMonitorBotApplication {
 
     public static void main(String[] args) {

src/main/java/ru/ldeloff/servermonitorbot/config/SshConfig.java

@@ -0,0 +1,18 @@
+package ru.ldeloff.servermonitorbot.config;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.Setter;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+import ru.ldeloff.servermonitorbot.model.SshServer;
+
+import java.util.List;
+
+@Configuration
+@ConfigurationProperties(prefix = "ssh")
+@Getter
+@Setter
+public class SshConfig {
+    private List<SshServer> servers;
+}

src/main/java/ru/ldeloff/servermonitorbot/config/UserConfig.java

@@ -0,0 +1,17 @@
+package ru.ldeloff.servermonitorbot.config;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+import ru.ldeloff.servermonitorbot.model.dto.InitUserDto;
+
+import java.util.List;
+
+@Configuration
+@ConfigurationProperties(prefix = "bot")
+@Getter
+@Setter
+public class UserConfig {
+    private List<InitUserDto> users;
+}

src/main/java/ru/ldeloff/servermonitorbot/controller/TelegramBotController.java

@@ -0,0 +1,98 @@
+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.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.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.uname.UnameAggregateCommand;
+import ru.ldeloff.servermonitorbot.service.command.uname.UnameCommand;
+
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class TelegramBotController extends TelegramLongPollingBot {
+    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;
+
+    @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);
+                    }
+                    case "Статус" -> {
+                        getStatusSessions.execute(update, this);
+                    }
+                    case "uname" -> {
+                        unameAggregateCommand.execute(update, this);
+                    }
+                    case "CPU.temp" -> {
+                        cpuTempAggregateCommand.execute(update, this);
+                    }
+                    case "HDD.temp" -> {
+                        hddTempAggregateCommand.execute(update, this);
+                    }
+                    default -> {
+                        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);
+                    }
+                    default -> {
+                        switchToMainMenu.execute(update, this);
+                    }
+                }
+            } else {
+                switchToMainMenu.execute(update, this);
+            }
+        }
+    }
+    @Override
+    public String getBotUsername() {
+        return telegramBot.getBotUsername();
+    }
+    @Override
+    public String getBotToken() {
+        return telegramBot.getBotToken();
+    }
+    @Override
+    public void onClosing() {
+        super.onClosing();
+        sshRepository.disconnectSessions();
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/init/AddUsers.java

@@ -0,0 +1,34 @@
+package ru.ldeloff.servermonitorbot.init;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.ApplicationArguments;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.stereotype.Component;
+import ru.ldeloff.servermonitorbot.config.UserConfig;
+import ru.ldeloff.servermonitorbot.mapper.UserMapper;
+import ru.ldeloff.servermonitorbot.model.User;
+import ru.ldeloff.servermonitorbot.model.dto.InitUserDto;
+import ru.ldeloff.servermonitorbot.service.user.UserService;
+
+import java.util.List;
+
+@Component
+public class AddUsers implements ApplicationRunner {
+    final List<InitUserDto> initUsers;
+    final UserService userService;
+    final UserMapper userMapper;
+
+    @Autowired
+    public AddUsers(UserConfig userConfig, UserService userService, UserMapper userMapper) {
+        this.initUsers = userConfig.getUsers();
+        this.userService = userService;
+        this.userMapper = userMapper;
+    }
+
+    @Override
+    public void run(ApplicationArguments args) throws Exception {
+        initUsers.forEach(initUserDto -> {
+            User user = userService.saveOrUpdateUser(userMapper.dtoToUser(initUserDto));
+        });
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/init/SshConnect.java

@@ -0,0 +1,20 @@
+package ru.ldeloff.servermonitorbot.init;
+
+import org.springframework.boot.ApplicationArguments;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.stereotype.Component;
+import ru.ldeloff.servermonitorbot.repository.SshRepository;
+
+@Component
+public class SshConnect implements ApplicationRunner {
+    final SshRepository sshRepository;
+
+    public SshConnect(SshRepository sshRepository) {
+        this.sshRepository = sshRepository;
+    }
+
+    @Override
+    public void run(ApplicationArguments args) throws Exception {
+        sshRepository.connectToAllServer();
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/init/StartBot.java

@@ -1,4 +1,4 @@
-package ru.ldeloff.servermonitorbot;
+package ru.ldeloff.servermonitorbot.init;
 
 import lombok.NoArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -9,16 +9,16 @@ import org.springframework.stereotype.Component;
 import org.telegram.telegrambots.meta.TelegramBotsApi;
 import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
 import org.telegram.telegrambots.updatesreceivers.DefaultBotSession;
-import ru.ldeloff.servermonitorbot.model.TelegramBot;
+import ru.ldeloff.servermonitorbot.controller.TelegramBotController;
 
 @Slf4j
 @Component
 @NoArgsConstructor
 public class StartBot implements ApplicationRunner {
-    private TelegramBot telegramBot;
+    private TelegramBotController telegramBot;
 
     @Autowired
-    public StartBot(TelegramBot telegramBot) {
+    public StartBot(TelegramBotController telegramBot) {
         this.telegramBot = telegramBot;
     }
 

src/main/java/ru/ldeloff/servermonitorbot/mapper/UserMapper.java

@@ -0,0 +1,22 @@
+package ru.ldeloff.servermonitorbot.mapper;
+
+import org.springframework.stereotype.Component;
+import ru.ldeloff.servermonitorbot.model.User;
+import ru.ldeloff.servermonitorbot.model.dto.InitUserDto;
+import ru.ldeloff.servermonitorbot.service.role.RoleService;
+
+@Component
+public class UserMapper {
+    final RoleService roleService;
+
+    public UserMapper(RoleService roleService) {
+        this.roleService = roleService;
+    }
+
+    public User dtoToUser(InitUserDto initUserDto) {
+        User user = new User();
+        user.setTelegramId(initUserDto.getTelegramId());
+        user.setRole(roleService.findRoleByName(initUserDto.getRole()));
+        return user;
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/model/Command.java

@@ -0,0 +1,25 @@
+package ru.ldeloff.servermonitorbot.model;
+
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotNull;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class Command {
+    @NotNull
+    private String command;
+    @NotNull
+    @Min(100)
+    private int timeout;
+    @NotNull
+    private SshServer sshServer;
+    private String response;
+
+    public Command(String command, int timeout, SshServer sshServer) {
+        this.command = command;
+        this.timeout = timeout;
+        this.sshServer = sshServer;
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/model/Role.java

@@ -0,0 +1,17 @@
+package ru.ldeloff.servermonitorbot.model;
+
+import jakarta.persistence.*;
+import lombok.Data;
+
+@Entity
+@Data
+@Table(name = "roles")
+public class Role {
+    @Id
+    @Column(name = "id")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private long id;
+
+    @Column(name = "name")
+    private String name;
+}

src/main/java/ru/ldeloff/servermonitorbot/model/SshServer.java

@@ -0,0 +1,24 @@
+package ru.ldeloff.servermonitorbot.model;
+
+import com.jcraft.jsch.Session;
+import jakarta.validation.constraints.NotNull;
+import lombok.Getter;
+import lombok.Setter;
+import org.springframework.stereotype.Component;
+
+@Setter
+@Getter
+@Component
+public class SshServer {
+    @NotNull
+    private String name;
+    @NotNull
+    private String host;
+    @NotNull
+    private int port;
+    @NotNull
+    private String user;
+    @NotNull
+    private String password;
+    private Session session;
+}

src/main/java/ru/ldeloff/servermonitorbot/model/TelegramBot.java

@@ -1,47 +1,17 @@
 package ru.ldeloff.servermonitorbot.model;
 
-import lombok.AllArgsConstructor;
+import lombok.Getter;
-import lombok.NoArgsConstructor;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Component;
-import org.telegram.telegrambots.bots.TelegramLongPollingBot;
-import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
-import org.telegram.telegrambots.meta.api.objects.Update;
-import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
 
+@Getter
 @Component
-@NoArgsConstructor
+public class TelegramBot{
-@AllArgsConstructor
+    private final String botUsername;
-public class TelegramBot extends TelegramLongPollingBot {
+    private final String botToken;
-    @Value("${bot.name}")
-    private String botUsername;
 
-    @Value("${bot.token}")
+    public TelegramBot(@Value("${bot.name}") String botUsername, @Value("${bot.token}") String botToken) {
-    private String botToken;
+        this.botUsername = botUsername;
-
+        this.botToken = botToken;
-    @Override
-    public void onUpdateReceived(Update update) {
-        // We check if the update has a message and the message has text
-        if (update.hasMessage() && update.getMessage().hasText()) {
-            SendMessage message = new SendMessage(); // Create a SendMessage object with mandatory fields
-            message.setChatId(update.getMessage().getChatId().toString());
-            message.setText(update.getMessage().getText());
-
-            try {
-                execute(message); // Call method to send the message
-            } catch (TelegramApiException e) {
-                e.printStackTrace();
-            }
-        }
-    }
-
-    @Override
-    public String getBotUsername() {
-        return botUsername;
-    }
-
-    @Override
-    public String getBotToken() {
-        return botToken;
     }
 }

src/main/java/ru/ldeloff/servermonitorbot/model/User.java

@@ -0,0 +1,24 @@
+package ru.ldeloff.servermonitorbot.model;
+
+import jakarta.persistence.*;
+import lombok.Data;
+
+@Entity
+@Data
+@Table(name = "users")
+public class User {
+    @Id
+    @Column(name = "id")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "telegram_id")
+    private Long telegramId;
+
+    @ManyToOne
+    @JoinColumn(name = "role_id")
+    private Role role;
+
+    @Transient
+    private String login;
+}

src/main/java/ru/ldeloff/servermonitorbot/model/dto/InitUserDto.java

@@ -0,0 +1,14 @@
+package ru.ldeloff.servermonitorbot.model.dto;
+
+import jakarta.validation.constraints.NotNull;
+import lombok.Data;
+import org.springframework.stereotype.Component;
+
+@Data
+@Component
+public class InitUserDto {
+    @NotNull
+    private long telegramId;
+    @NotNull
+    private String role;
+}

src/main/java/ru/ldeloff/servermonitorbot/repository/RoleRepository.java

@@ -0,0 +1,13 @@
+package ru.ldeloff.servermonitorbot.repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+import ru.ldeloff.servermonitorbot.model.Role;
+
+import java.util.Optional;
+
+@Repository
+public interface RoleRepository extends JpaRepository<Role, Long> {
+    Optional<Role> findRoleByName(String name);
+    Optional<Role> findRoleById(Long id);
+}

src/main/java/ru/ldeloff/servermonitorbot/repository/SshRepository.java

@@ -0,0 +1,16 @@
+package ru.ldeloff.servermonitorbot.repository;
+
+import com.jcraft.jsch.JSchException;
+import com.jcraft.jsch.Session;
+import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
+import ru.ldeloff.servermonitorbot.model.SshServer;
+
+import java.util.List;
+
+public interface SshRepository {
+    void connectToAllServer();
+    Session connectToServer(SshServer sshServer) throws JSchException;
+    void disconnectSessions();
+    String getStatusSessions();
+    List<SshServer> getSshServers();
+}

src/main/java/ru/ldeloff/servermonitorbot/repository/SshRepositoryImpl.java

@@ -0,0 +1,88 @@
+package ru.ldeloff.servermonitorbot.repository;
+
+import com.jcraft.jsch.JSch;
+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.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;
+
+@Slf4j
+@Repository
+public class SshRepositoryImpl implements SshRepository {
+
+    private final List<SshServer> sshServers;
+
+    @Autowired
+    public SshRepositoryImpl(SshConfig sshConfig) {
+        this.sshServers = sshConfig.getServers();
+    }
+
+    private List<Session> sessions = new ArrayList<>();
+
+    @Override
+    public void connectToAllServer() {
+        sshServers.forEach(sshServer -> {
+            try {
+                Session session = connectToServer(sshServer);
+                sshServer.setSession(session);
+                log.info("Успешно подключён к " + sshServer.getHost());
+                sessions.add(session);
+            } catch (JSchException e) {
+                log.warn("Не удалось соединиться с " + sshServer.getHost() + ": " + e.getMessage());
+            }
+        });
+    }
+
+    @Override
+    public Session connectToServer(SshServer sshServer) throws JSchException {
+        Session session = new JSch().getSession(sshServer.getUser(),
+                sshServer.getHost(),
+                sshServer.getPort());
+        session.setPassword(sshServer.getPassword());
+        session.setConfig("StrictHostKeyChecking", "no");
+        session.connect();
+        return session;
+    }
+
+    @Override
+    public void disconnectSessions() {
+        if (!sessions.isEmpty()) {
+            sessions.forEach(Session::disconnect);
+            sessions.forEach(sessions::remove);
+        }
+    }
+
+    @Override
+    public String getStatusSessions() {
+        StringBuilder text = new StringBuilder("Статус соединения: \n");
+        sshServers.forEach(server -> {
+            text.append(server.getName())
+                    .append(": ")
+                    .append(checkStatusServer(server))
+                    .append("\n");
+        });
+        return String.valueOf(text);
+    }
+
+    @Override
+    public List<SshServer> getSshServers() {
+        return sshServers;
+    }
+
+    private String checkStatusServer(SshServer server) {
+        if (Objects.isNull(server.getSession())) {
+            return "нет соединения";
+        } else {
+            return server.getSession().isConnected() ? "OK" : "отключён";
+        }
+    }
+
+}

src/main/java/ru/ldeloff/servermonitorbot/repository/UserRepository.java

@@ -0,0 +1,10 @@
+package ru.ldeloff.servermonitorbot.repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+import ru.ldeloff.servermonitorbot.model.User;
+
+@Repository
+public interface UserRepository extends JpaRepository<User, Long> {
+    User getByTelegramId(long id);
+}

src/main/java/ru/ldeloff/servermonitorbot/service/command/CommandTemplate.java

@@ -0,0 +1,87 @@
+package ru.ldeloff.servermonitorbot.service.command;
+
+import lombok.Data;
+import lombok.RequiredArgsConstructor;
+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.User;
+import ru.ldeloff.servermonitorbot.service.role.RoleService;
+import ru.ldeloff.servermonitorbot.service.user.UserService;
+
+@Data
+@Slf4j
+@RequiredArgsConstructor
+public abstract class CommandTemplate {
+    final UserService userService;
+    final RoleService roleService;
+    long expectedRole = 2L;
+    public abstract SendMessage actionForAuth(User user, SendMessage message);
+
+    public SendMessage actionForNotAuth(User user, SendMessage message) {
+        message.setText("У пользователя " + user.getLogin() + " (" + user.getTelegramId()
+                + ") недостаточно прав для выполнения этой команды");
+        return message;
+    }
+    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 {
+            logNotAuth(user, message);
+            sendMessage(actionForNotAuth(user, answer), bot);
+        }
+    }
+    protected void logSuccess(User user, String message) {
+        log.info("Получена команда '" + message + "' от " + user.getLogin()
+                + " (" + user.getTelegramId() + "). OK");
+    }
+    protected void logNotAuth(User user, String message) {
+        log.warn("Получена команда '" + message + "' от " + user.getLogin()
+                + " (" + user.getTelegramId() + "). Нет прав");
+    }
+    private User getUser(Update update) {
+        long id = -1L;
+        String login = null;
+        if (update.hasMessage()) {
+            id = update.getMessage().getChat().getId();
+            login = update.getMessage().getChat().getUserName();
+        } else if (update.hasCallbackQuery()) {
+            id = update.getCallbackQuery().getMessage().getChat().getId();
+            login = update.getCallbackQuery().getMessage().getChat().getUserName();
+        }
+        User user = userService.getByTelegramId(id);
+        if (user == null) {
+            user = new User();
+            user.setTelegramId(id);
+            user.setRole(roleService.findRoleById(3L));
+        }
+        user.setLogin(login);
+        return user;
+    }
+
+    private String getMessage(Update update) {
+        if (update.hasMessage()) {
+            return update.getMessage().getText();
+        } else if (update.hasCallbackQuery()) {
+            return update.getCallbackQuery().getData();
+        }
+        return "";
+    }
+
+    private void sendMessage(SendMessage message, TelegramBotController bot) {
+        try {
+            bot.execute(message);
+        } catch (TelegramApiException e) {
+            e.printStackTrace();
+            log.warn(e.getMessage());
+        }
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/service/command/FirstUseCommand.java

@@ -0,0 +1,23 @@
+package ru.ldeloff.servermonitorbot.service.command;
+
+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.role.RoleService;
+import ru.ldeloff.servermonitorbot.service.user.UserService;
+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);
+        this.telegramBotKeyboard = telegramBotKeyboard;
+    }
+    @Override
+    public SendMessage actionForAuth(User user, SendMessage message) {
+        message.setText("Добро пожаловать " + user.getLogin() + "!");
+        return telegramBotKeyboard.uiForm(message);
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/service/command/GetStatusSessions.java

@@ -0,0 +1,23 @@
+package ru.ldeloff.servermonitorbot.service.command;
+
+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.role.RoleService;
+import ru.ldeloff.servermonitorbot.service.ssh.SshService;
+import ru.ldeloff.servermonitorbot.service.user.UserService;
+
+@Service
+public class GetStatusSessions extends CommandTemplate {
+    final SshService sshService;
+
+    public GetStatusSessions(UserService userService, RoleService roleService, SshService sshService) {
+        super(userService, roleService);
+        this.sshService = sshService;
+    }
+
+    @Override
+    public SendMessage actionForAuth(User user, SendMessage message) {
+        return sshService.getStatusSessions(message);
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/service/command/SwitchToMainMenu.java

@@ -0,0 +1,35 @@
+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.User;
+import ru.ldeloff.servermonitorbot.service.role.RoleService;
+import ru.ldeloff.servermonitorbot.service.user.UserService;
+import ru.ldeloff.servermonitorbot.utils.ui.TelegramBotKeyboard;
+
+@Service
+@Slf4j
+public class SwitchToMainMenu extends CommandTemplate {
+    final TelegramBotKeyboard telegramBotKeyboard;
+
+    public SwitchToMainMenu(UserService userService, RoleService roleService, TelegramBotKeyboard telegramBotKeyboard) {
+        super(userService, roleService);
+        this.telegramBotKeyboard = telegramBotKeyboard;
+    }
+    @Override
+    public SendMessage actionForAuth(User user, SendMessage message) {
+        message.setText("Неверная команда. Попробуем сначала.");
+        return telegramBotKeyboard.uiForm(message);
+    }
+    @Override
+    public 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() + "). Нет прав");
+    }
+}

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

@@ -0,0 +1,24 @@
+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);
+    }
+}

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

@@ -0,0 +1,67 @@
+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;
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+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);
+    }
+}

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

@@ -0,0 +1,64 @@
+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;
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+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);
+    }
+}

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

@@ -0,0 +1,63 @@
+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;
+        }
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/service/role/RoleService.java

@@ -0,0 +1,9 @@
+package ru.ldeloff.servermonitorbot.service.role;
+
+import ru.ldeloff.servermonitorbot.model.Role;
+
+public interface RoleService {
+    Role findRoleByName(String name);
+
+    Role findRoleById(Long id);
+}

src/main/java/ru/ldeloff/servermonitorbot/service/role/RoleServiceImpl.java

@@ -0,0 +1,28 @@
+package ru.ldeloff.servermonitorbot.service.role;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import ru.ldeloff.servermonitorbot.model.Role;
+import ru.ldeloff.servermonitorbot.repository.RoleRepository;
+
+import java.util.Locale;
+import java.util.Optional;
+
+@Service
+@RequiredArgsConstructor
+public class RoleServiceImpl implements RoleService {
+    private final RoleRepository roleRepository;
+
+    @Override
+    public Role findRoleByName(String name) {
+        Optional<Role> role = roleRepository.findRoleByName(name.toUpperCase(Locale.ROOT));
+        //noinspection OptionalGetWithoutIsPresent
+        return role.orElseGet(() -> roleRepository.findRoleByName("ANONYMOUS").get());
+    }
+
+    @Override
+    public Role findRoleById(Long id) {
+        Optional<Role> role = roleRepository.findRoleById(id);
+        return role.orElseGet(() -> roleRepository.findRoleByName("ANONYMOUS").get());
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/service/ssh/SshService.java

@@ -0,0 +1,16 @@
+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.SshServer;
+
+import java.util.List;
+
+public interface SshService {
+    SendMessage getStatusSessions(SendMessage update);
+
+    List<SshServer> getSshServers();
+    Command execute(Command command);
+    List<Command> execute(List<Command> commands);
+}

src/main/java/ru/ldeloff/servermonitorbot/service/ssh/SshServiceImpl.java

@@ -0,0 +1,74 @@
+package ru.ldeloff.servermonitorbot.service.ssh;
+
+import com.jcraft.jsch.ChannelExec;
+import com.jcraft.jsch.JSchException;
+import com.jcraft.jsch.Session;
+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.SshServer;
+import ru.ldeloff.servermonitorbot.repository.SshRepository;
+
+import java.io.ByteArrayOutputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class SshServiceImpl implements SshService {
+    final SshRepository sshRepository;
+    @Override
+    public SendMessage getStatusSessions(SendMessage message) {
+        message.setText(sshRepository.getStatusSessions());
+        return message;
+    }
+    @Override
+    public List<SshServer> getSshServers() {
+        return sshRepository.getSshServers();
+    }
+
+    @Override
+    public Command execute(Command command) {
+        List<Command> commands = new ArrayList<>();
+        commands.add(command);
+        return execute(commands).get(0);
+    }
+
+    @Override
+    public List<Command> execute(List<Command> commands) {
+        Session session = commands.get(0).getSshServer().getSession(); // подразумевается, что в листе с командами сервер один и тот же
+        ChannelExec channel = null;
+        try {
+            channel = (ChannelExec) session.openChannel("exec");
+            ChannelExec finalChannel = channel;
+
+            commands.forEach(command -> {
+                try {
+                    finalChannel.setCommand(command.getCommand());
+                    ByteArrayOutputStream responseStream = new ByteArrayOutputStream();
+                    finalChannel.setOutputStream(responseStream);
+                    finalChannel.connect();
+                    while (finalChannel.isConnected()) {
+                        Thread.sleep(command.getTimeout());
+                    }
+                    String responseString = new String(responseStream.toByteArray());
+                    command.setResponse(responseString);
+                } catch (JSchException | InterruptedException e) {
+                    log.warn(e.getMessage());
+                    throw new RuntimeException(e);
+                }
+            });
+        } catch (JSchException e) {
+            log.warn(e.getMessage());
+            throw new RuntimeException(e);
+        } finally {
+            if (channel != null) {
+                channel.disconnect();
+            }
+        }
+        return commands;
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/service/user/UserService.java

@@ -0,0 +1,9 @@
+package ru.ldeloff.servermonitorbot.service.user;
+
+import ru.ldeloff.servermonitorbot.model.User;
+
+public interface UserService {
+    User saveOrUpdateUser(User user);
+
+    User getByTelegramId(Long id);
+}

src/main/java/ru/ldeloff/servermonitorbot/service/user/UserServiceImpl.java

@@ -0,0 +1,29 @@
+package ru.ldeloff.servermonitorbot.service.user;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import ru.ldeloff.servermonitorbot.model.User;
+import ru.ldeloff.servermonitorbot.repository.UserRepository;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class UserServiceImpl implements UserService {
+
+    final UserRepository userRepository;
+
+    @Override
+    public User saveOrUpdateUser(User user) {
+        User existUser = userRepository.getByTelegramId(user.getTelegramId());
+        if (existUser != null) {
+            user.setId(existUser.getId());
+        }
+        return userRepository.save(user);
+    }
+
+    @Override
+    public User getByTelegramId(Long id) {
+        return userRepository.getByTelegramId(id);
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/utils/SshServerUtils.java

@@ -0,0 +1,17 @@
+package ru.ldeloff.servermonitorbot.utils;
+
+import ru.ldeloff.servermonitorbot.model.SshServer;
+
+import java.util.List;
+import java.util.Objects;
+
+public class SshServerUtils {
+    public static List<SshServer> filterGoodServers(List<SshServer> sshServers) {
+        List<SshServer> goodSshServers = sshServers.stream()
+                .filter(Objects::nonNull)
+                .filter(server -> Objects.nonNull(server.getSession()))
+                .filter(server -> server.getSession().isConnected())
+                .toList();
+        return goodSshServers;
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/utils/ui/TelegramBotKeyboard.java

@@ -0,0 +1,40 @@
+package ru.ldeloff.servermonitorbot.utils.ui;
+
+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 java.util.ArrayList;
+
+@Component
+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";
+
+
+    @Override
+    public SendMessage uiForm(SendMessage message) {
+        ReplyKeyboardMarkup replyKeyboardMarkup = new ReplyKeyboardMarkup();
+        replyKeyboardMarkup.setResizeKeyboard(true);
+        replyKeyboardMarkup.setOneTimeKeyboard(false);
+
+        ArrayList<KeyboardRow> keyboardRows = new ArrayList<>();
+
+        KeyboardRow keyboardRow = new KeyboardRow();
+        keyboardRows.add(keyboardRow);
+
+        keyboardRow.add(new KeyboardButton(STATUS));
+        keyboardRow.add(new KeyboardButton(UNAME));
+        keyboardRow.add(new KeyboardButton(CPU_TEMP));
+        keyboardRow.add(new KeyboardButton(HDD_TEMP));
+
+        replyKeyboardMarkup.setKeyboard(keyboardRows);
+        message.setReplyMarkup(replyKeyboardMarkup);
+        return message;
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/utils/ui/UiFormer.java

@@ -0,0 +1,7 @@
+package ru.ldeloff.servermonitorbot.utils.ui;
+
+import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
+
+public interface UiFormer {
+    SendMessage uiForm(SendMessage message);
+}

src/main/java/ru/ldeloff/servermonitorbot/utils/ui/uname/ServerListButtons.java

@@ -0,0 +1,55 @@
+package ru.ldeloff.servermonitorbot.utils.ui.uname;
+
+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.service.ssh.SshService;
+import ru.ldeloff.servermonitorbot.utils.ui.UiFormer;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+@Component
+@RequiredArgsConstructor
+public class ServerListButtons implements UiFormer {
+
+    private final SshService sshService;
+
+    @Override
+    public SendMessage uiForm(SendMessage message) {
+        List<List<InlineKeyboardButton>> keyboard = new ArrayList<>();
+
+        InlineKeyboardMarkup inlineKeyboardMarkup = new InlineKeyboardMarkup();
+
+        sshService.getSshServers().forEach(sshServer -> {
+            if (Objects.nonNull(sshServer.getSession())) {
+                if (sshServer.getSession().isConnected()) {
+                    List<InlineKeyboardButton> keyboardRow = new ArrayList<>();
+                    InlineKeyboardButton inlineKeyboardButton = new InlineKeyboardButton();
+                    inlineKeyboardButton.setText(sshServer.getName());
+                    inlineKeyboardButton.setCallbackData(message.getText() + ": " + sshServer.getName());
+                    keyboardRow.add(inlineKeyboardButton);
+                    keyboard.add(keyboardRow);
+                }
+            }
+        });
+
+        if (keyboard.size() > 1) {
+            List<InlineKeyboardButton> keyboardRow = new ArrayList<>();
+            InlineKeyboardButton inlineKeyboardButton = new InlineKeyboardButton();
+            inlineKeyboardButton.setText("Все сервера");
+            inlineKeyboardButton.setCallbackData(message.getText() + ": all");
+            keyboardRow.add(inlineKeyboardButton);
+            keyboard.add(keyboardRow);
+        }
+
+        inlineKeyboardMarkup.setKeyboard(keyboard);
+        message.setReplyMarkup(inlineKeyboardMarkup);
+        message.setText("Выполнить " + message.getText() + " для");
+
+        return message;
+    }
+}

src/main/resources/application.yml

@@ -1,5 +1,35 @@
+spring:
+  application:
+    name: ServerMonitorBot
+  datasource:
+    url: jdbc:postgresql://localhost:5432/servermonitorbot
+    username: servermonitorbot
+    password: servermonitorbot
+  jpa:
+    hibernate:
+      ddl-auto: none
+  liquibase:
+    enabled: true
+    change-log: classpath:db/scripts/changelog-master.xml
+    url: jdbc:postgresql://localhost:5432/servermonitorbot
+    user: servermonitorbot
+    password: servermonitorbot
+    liquibase-schema: "liquibase"
+    default-schema: "servermonitorbot"
 bot:
   name: "ServerMonitorBot"
   token: "token"
+  users:
+    - telegramId: 123456789
+      role: admin
+ssh:
+  servers:
+    -
+      name: "Server Name"
+      host: "url"
+      port: 22
+      user: "user"
+      password: "pass"
+
 
 

src/main/resources/db/scripts/changelog-master.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<databaseChangeLog
+        xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.1.xsd">
+
+    <include file="release_0_0_1/changelog.xml" relativeToChangelogFile="true"/>
+
+
+</databaseChangeLog>

src/main/resources/db/scripts/release_0_0_1/changelog.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<databaseChangeLog
+        xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.1.xsd">
+
+    <include file="scripts/01_create_table_users.sql" relativeToChangelogFile="true"/>
+    <include file="scripts/02_create_table_roles.sql" relativeToChangelogFile="true"/>
+    <include file="scripts/03_add_FK_users_to_roles.sql" relativeToChangelogFile="true"/>
+    <include file="scripts/04_add_roles.sql" relativeToChangelogFile="true"/>
+    <include file="scripts/05_add_anonymous_role.sql" relativeToChangelogFile="true"/>
+    <include file="scripts/06_refactor_users_table.sql" relativeToChangelogFile="true"/>
+    <include file="scripts/07_refactor_roles_table.sql" relativeToChangelogFile="true"/>
+    <include file="scripts/08_add_roles.sql" relativeToChangelogFile="true"/>
+
+</databaseChangeLog>

src/main/resources/db/scripts/release_0_0_1/scripts/01_create_table_users.sql

@@ -0,0 +1,17 @@
+--liquibase formatted sql
+
+--changeset L_DelOff:create_table_users rollbackSplitStatements:true
+--comment: Создание таблицы пользователей
+CREATE TABLE users
+(
+    id       SERIAL        PRIMARY KEY,
+    login    VARCHAR(128),
+    id_role  integer
+);
+
+COMMENT ON TABLE users IS 'Пользователи';
+COMMENT ON COLUMN users.id IS 'Идентификатор пользователя';
+COMMENT ON COLUMN users.login IS 'Логин пользователя';
+COMMENT ON COLUMN users.id_role IS 'Ссылка на роль пользователя';
+
+--rollback DROP TABLE users;

src/main/resources/db/scripts/release_0_0_1/scripts/02_create_table_roles.sql

@@ -0,0 +1,15 @@
+--liquibase formatted sql
+
+--changeset L_DelOff:create_table_roles rollbackSplitStatements:true
+--comment: Создание таблицы ролей
+CREATE TABLE roles
+(
+    id       SERIAL        PRIMARY KEY,
+    role    VARCHAR(128)
+);
+
+COMMENT ON TABLE roles IS 'Пользователи';
+COMMENT ON COLUMN roles.id IS 'Идентификатор пользователя';
+COMMENT ON COLUMN roles.role IS 'Логин пользователя';
+
+--rollback DROP TABLE roles;

src/main/resources/db/scripts/release_0_0_1/scripts/03_add_FK_users_to_roles.sql

@@ -0,0 +1,2 @@
+ALTER TABLE users
+ADD COLUMN role_id INT NOT NULL REFERENCES roles(id);

src/main/resources/db/scripts/release_0_0_1/scripts/04_add_roles.sql

@@ -0,0 +1,2 @@
+INSERT INTO roles (id, role) VALUES (1, 'ADMIN');
+INSERT INTO roles (id, role) VALUES (2, 'USER');

src/main/resources/db/scripts/release_0_0_1/scripts/05_add_anonymous_role.sql

@@ -0,0 +1 @@
+INSERT INTO roles (id, role) VALUES (3, 'ANONYMOUS');

src/main/resources/db/scripts/release_0_0_1/scripts/06_refactor_users_table.sql

@@ -0,0 +1,9 @@
+ALTER TABLE users
+    DROP COLUMN login;
+
+ALTER TABLE users
+    ADD COLUMN telegram_id INTEGER UNIQUE;
+    COMMENT ON COLUMN users.telegram_id IS 'Telegram ID пользователя';
+
+ALTER TABLE users
+    DROP COLUMN id_role;

src/main/resources/db/scripts/release_0_0_1/scripts/07_refactor_roles_table.sql

@@ -0,0 +1,6 @@
+ALTER TABLE roles
+    DROP COLUMN role;
+
+ALTER TABLE roles
+    ADD COLUMN name VARCHAR(128);
+COMMENT ON COLUMN roles.name IS 'Имя роли';

src/main/resources/db/scripts/release_0_0_1/scripts/08_add_roles.sql

@@ -0,0 +1,4 @@
+TRUNCATE TABLE roles CASCADE;
+INSERT INTO roles (id, name) VALUES (1, 'ADMIN');
+INSERT INTO roles (id, name) VALUES (2, 'USER');
+INSERT INTO roles (id, name) VALUES (3, 'ANONYMOUS');