Merge pull request 'feature/add-uname-command' (#4) from feature/add-uname-command into master

Reviewed-on: L_DelOff/ServerMonitorBot#4

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

@@ -0,0 +1,87 @@
+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.methods.send.SendMessage;
+import org.telegram.telegrambots.meta.api.objects.Update;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
+import ru.ldeloff.servermonitorbot.model.TelegramBot;
+import ru.ldeloff.servermonitorbot.repository.SshRepository;
+import ru.ldeloff.servermonitorbot.service.TelegramBotService;
+import ru.ldeloff.servermonitorbot.utils.ui.TelegramBotKeyboard;
+import ru.ldeloff.servermonitorbot.utils.ui.uname.UnameChatButtonAggregate;
+
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class TelegramBotController extends TelegramLongPollingBot {
+
+    final TelegramBot telegramBot;
+    final SshRepository sshRepository;
+    final TelegramBotKeyboard telegramBotKeyboard;
+    final UnameChatButtonAggregate unameChatButtonAggregate;
+    final TelegramBotService telegramBotService;
+
+    @Override
+    public void onUpdateReceived(Update update) {
+        if (update.hasMessage()) {
+            if (update.getMessage().hasText()) {
+                String messageText = update.getMessage().getText();
+                switch (messageText) {
+                    case "/start" -> {
+                        log.info("Получена команда /start");
+                        telegramBotService.firstUse(update, this);
+                    }
+                    case "Статус" -> {
+                        log.info("Получена команда 'Статус'");
+                        telegramBotService.getStatusSessions(update, this);
+                    }
+                    case "uname" -> {
+                        log.info("Получена команда 'uname'");
+                        telegramBotService.sendUnameAggregate(update, this);
+                    }
+                    default -> {
+                        log.warn("Неизвестная команда:" + messageText);
+                        telegramBotService.switchToMainMenu(update, this);
+                    }
+                }
+            }
+        } else if (update.hasCallbackQuery()) {
+            String messageText = update.getCallbackQuery().getData();
+            String [] tags = messageText.split(":");
+            if (tags.length > 1) {
+                switch (tags[0]) {
+                    case "uname":
+                        log.info("Получена команда '" + messageText + "'");
+                        telegramBotService.uname(update, this);
+                        break;
+                    default:
+                        log.warn("Неизвестная команда:" + messageText);
+                        telegramBotService.switchToMainMenu(update, this);
+                        break;
+                }
+            } else {
+                    log.warn("Неверный формат команды:" + messageText);
+                    telegramBotService.switchToMainMenu(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/SshConnect.java

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

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

@@ -9,17 +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;
-import ru.ldeloff.servermonitorbot.service.TelegramBotService;
 
 @Slf4j
 @Component
 @NoArgsConstructor
 public class StartBot implements ApplicationRunner {
-    private TelegramBotService telegramBot;
+    private TelegramBotController telegramBot;
 
     @Autowired
-    public StartBot(TelegramBotService telegramBot) {
+    public StartBot(TelegramBotController telegramBot) {
         this.telegramBot = telegramBot;
     }
 

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

@@ -1,4 +1,4 @@
-package ru.ldeloff.servermonitorbot.service;
+package ru.ldeloff.servermonitorbot.repository;
 
 import com.jcraft.jsch.JSchException;
 import com.jcraft.jsch.Session;
@@ -7,10 +7,10 @@ import ru.ldeloff.servermonitorbot.model.SshServer;
 
 import java.util.List;
 
-
+public interface SshRepository {
-public interface SshService {
     void connectToAllServer();
     Session connectToServer(SshServer sshServer) throws JSchException;
     void disconnectSessions();
-    SendMessage getStatusSessions(Long chatId);
+    String getStatusSessions();
+    List<SshServer> getSshServers();
 }

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

@@ -1,11 +1,11 @@
-package ru.ldeloff.servermonitorbot.service;
+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.Service;
+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;
@@ -14,13 +14,13 @@ import java.util.ArrayList;
 import java.util.List;
 
 @Slf4j
-@Service
+@Repository
-public class SshServiceImpl implements SshService{
+public class SshRepositoryImpl implements SshRepository {
 
     private final List<SshServer> sshServers;
 
     @Autowired
-    public SshServiceImpl(SshConfig sshConfig) {
+    public SshRepositoryImpl(SshConfig sshConfig) {
         this.sshServers = sshConfig.getServers();
     }
 
@@ -60,7 +60,7 @@ public class SshServiceImpl implements SshService{
     }
 
     @Override
-    public SendMessage getStatusSessions(Long chatId) {
+    public String getStatusSessions() {
         StringBuilder text = new StringBuilder("Статус соединения: \n");
         sshServers.forEach(server -> {
             text.append(server.getName())
@@ -68,9 +68,11 @@ public class SshServiceImpl implements SshService{
                     .append(server.getSession().isConnected() ? "OK" : "отключён")
                     .append("\n");
         });
-        SendMessage message = new SendMessage();
+        return String.valueOf(text);
-        message.setText(String.valueOf(text));
+    }
-        message.setChatId(chatId);
+
-        return message;
+    @Override
+    public List<SshServer> getSshServers() {
+        return sshServers;
     }
 }

src/main/java/ru/ldeloff/servermonitorbot/service/TelegramBotService.java

@@ -1,92 +1,13 @@
 package ru.ldeloff.servermonitorbot.service;
 
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-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;
+import ru.ldeloff.servermonitorbot.controller.TelegramBotController;
-import ru.ldeloff.servermonitorbot.model.TelegramBot;
-import ru.ldeloff.servermonitorbot.util.TelegramBotMenu;
 
-@Service
+public interface TelegramBotService {
-@Slf4j
-public class TelegramBotService extends TelegramLongPollingBot {
 
-    final TelegramBot telegramBot;
+    void switchToMainMenu(Update update, TelegramBotController bot);
-    final SshService sshService;
+    void getStatusSessions(Update update, TelegramBotController bot);
-    final TelegramBotMenu telegramBotMenu;
+    void sendUnameAggregate(Update update, TelegramBotController bot);
-
+    void uname(Update update, TelegramBotController bot);
-
+    void firstUse(Update update, TelegramBotController telegramBotController);
-    @Autowired
-    public TelegramBotService(TelegramBot telegramBot, SshService sshService, TelegramBotMenu telegramBotMenu) {
-        this.telegramBot = telegramBot;
-        this.sshService = sshService;
-        this.telegramBotMenu = telegramBotMenu;
-    }
-
-    @Override
-    public void onUpdateReceived(Update update) {
-        if (update.hasMessage()) {
-            if (update.getMessage().hasText()) {
-                SendMessage message = new SendMessage();
-                String messageText = update.getMessage().getText();
-                long chatId = update.getMessage().getChatId();
-                switch (messageText) {
-                    case "/start":
-                        message.setText("Привет: " + update.getMessage().getChat().getUserName());
-                        message.setChatId(chatId);
-                        message.setReplyMarkup(telegramBotMenu.initKeyboard());
-                        sendMessage(message);
-                        log.info("Получена команда /start");
-                        break;
-                    case "Статус":
-                        sendMessage(sshService.getStatusSessions(chatId));
-                        log.info("Получена команда 'Статус'");
-                        break;
-                    default:
-                        message.setText("unknown command:" + messageText);
-                        message.setChatId(chatId);
-                        message.setReplyMarkup(telegramBotMenu.initKeyboard());
-                        sendMessage(message);
-                        log.warn("Неизвестная команда:" + messageText);
-                }
-            }
-        } else if (update.hasCallbackQuery()) {
-            try {
-                SendMessage message = new SendMessage();
-                message.setText(update.getCallbackQuery().getData());
-                message.setChatId(update.getCallbackQuery().getMessage().getChatId());
-                execute(message);
-            } catch (TelegramApiException e) {
-                e.printStackTrace();
-            }
-        }
-    }
-
-    private void sendMessage(SendMessage message) {
-        try {
-            execute(message);
-        } catch (TelegramApiException e) {
-            e.printStackTrace();
-            log.warn(e.getMessage());
-        }
-    }
-
-    @Override
-    public String getBotUsername() {
-        return telegramBot.getBotUsername();
-    }
-
-    @Override
-    public String getBotToken() {
-        return telegramBot.getBotToken();
-    }
-
-    @Override
-    public void onClosing() {
-        super.onClosing();
-        sshService.disconnectSessions();
-    }
 }

src/main/java/ru/ldeloff/servermonitorbot/service/TelegramBotServiceImpl.java

@@ -0,0 +1,69 @@
+package ru.ldeloff.servermonitorbot.service;
+
+import lombok.RequiredArgsConstructor;
+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 org.telegram.telegrambots.meta.exceptions.TelegramApiException;
+import ru.ldeloff.servermonitorbot.controller.TelegramBotController;
+import ru.ldeloff.servermonitorbot.repository.SshRepository;
+import ru.ldeloff.servermonitorbot.service.ssh.SshService;
+import ru.ldeloff.servermonitorbot.service.uname.UnameService;
+import ru.ldeloff.servermonitorbot.utils.ui.TelegramBotKeyboard;
+import ru.ldeloff.servermonitorbot.utils.ui.uname.UnameChatButtonAggregate;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class TelegramBotServiceImpl implements TelegramBotService {
+    final TelegramBotKeyboard telegramBotKeyboard;
+    final UnameChatButtonAggregate unameChatButtonAggregate;
+    final UnameService unameService;
+    final SshService sshService;
+
+    @Override
+    public void firstUse(Update update, TelegramBotController bot) {
+        SendMessage message = new SendMessage();
+        long chatId = 0L;
+        chatId = update.getMessage().getChatId();
+        message.setText("Добро пожалвать " + update.getMessage().getChat().getUserName() + "!");
+        message.setChatId(chatId);
+        sendMessage(telegramBotKeyboard.uiForm(message), bot);
+    }
+    @Override
+    public void switchToMainMenu(Update update, TelegramBotController bot) {
+        SendMessage message = new SendMessage();
+        long chatId = 0L;
+        try {
+            chatId = update.getMessage().getChatId();
+        } catch (Exception e) {
+            chatId = update.getCallbackQuery().getMessage().getChatId();
+        }
+        message.setText("Неверная команда и или формат. Попробуем сначала.");
+        message.setChatId(chatId);
+        sendMessage(telegramBotKeyboard.uiForm(message), bot);
+    }
+    @Override
+    public void getStatusSessions(Update update, TelegramBotController bot) {
+        sendMessage(sshService.getStatusSessions(update), bot);
+    }
+    @Override
+    public void sendUnameAggregate(Update update, TelegramBotController bot) {
+        sendMessage(unameService.sendUnameAggregate(update), bot);
+    }
+
+    @Override
+    public void uname(Update update, TelegramBotController bot) {
+        sendMessage(unameService.uname(update), bot);
+    }
+
+    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/ssh/SshService.java

@@ -0,0 +1,16 @@
+package ru.ldeloff.servermonitorbot.service.ssh;
+
+
+import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
+import org.telegram.telegrambots.meta.api.objects.Update;
+import ru.ldeloff.servermonitorbot.model.SshServer;
+
+import java.util.List;
+
+public interface SshService {
+    SendMessage getStatusSessions(Update update);
+    List<SshServer> getSshServers();
+
+    String execute(String s, SshServer sshServer);
+    String execute(String s, SshServer sshServer, int timeout);
+}

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

@@ -0,0 +1,66 @@
+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 org.telegram.telegrambots.meta.api.objects.Update;
+import ru.ldeloff.servermonitorbot.model.SshServer;
+import ru.ldeloff.servermonitorbot.repository.SshRepository;
+
+import java.io.ByteArrayOutputStream;
+import java.util.List;
+
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class SshServiceImpl implements  SshService {
+    final SshRepository sshRepository;
+    @Override
+    public SendMessage getStatusSessions(Update update) {
+        SendMessage message = new SendMessage();
+        long chatId = update.getMessage().getChatId();
+        message.setText(sshRepository.getStatusSessions());
+        message.setChatId(chatId);
+        return message;
+    }
+    @Override
+    public List<SshServer> getSshServers() {
+        return sshRepository.getSshServers();
+    }
+
+    @Override
+    public String execute(String s, SshServer sshServer) {
+        return  execute(s, sshServer, 100);
+    }
+
+    @Override
+    public String execute(String s, SshServer sshServer, int timeout) {
+        Session session = sshServer.getSession();
+        ChannelExec channel = null;
+        try {
+            channel = (ChannelExec) session.openChannel("exec");
+            channel.setCommand(s);
+            ByteArrayOutputStream responseStream = new ByteArrayOutputStream();
+            channel.setOutputStream(responseStream);
+            channel.connect();
+
+            while (channel.isConnected()) {
+                Thread.sleep(timeout);
+            }
+
+            String responseString = new String(responseStream.toByteArray());
+            return responseString;
+        } catch (JSchException | InterruptedException e) {
+            log.error(e.getMessage());
+            return null;
+        } finally {
+            if (channel != null) {
+                channel.disconnect();
+            }
+        }
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/service/uname/UnameService.java

@@ -0,0 +1,10 @@
+package ru.ldeloff.servermonitorbot.service.uname;
+
+import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
+import org.telegram.telegrambots.meta.api.objects.Update;
+
+public interface UnameService {
+    SendMessage sendUnameAggregate(Update update);
+
+    SendMessage uname(Update update);
+}

src/main/java/ru/ldeloff/servermonitorbot/service/uname/UnameServiceImpl.java

@@ -0,0 +1,74 @@
+package ru.ldeloff.servermonitorbot.service.uname;
+
+import lombok.RequiredArgsConstructor;
+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.model.SshServer;
+import ru.ldeloff.servermonitorbot.service.ssh.SshService;
+import ru.ldeloff.servermonitorbot.utils.ui.uname.UnameChatButtonAggregate;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class UnameServiceImpl implements UnameService {
+    final SshService sshService;
+    final UnameChatButtonAggregate unameChatButtonAggregate;
+    @Override
+    public SendMessage sendUnameAggregate(Update update) {
+        SendMessage message = new SendMessage();
+        long chatId = update.getMessage().getChatId();
+        message.setChatId(chatId);
+        return unameChatButtonAggregate.uiForm(message);
+    }
+    @Override
+    public SendMessage uname(Update update) {
+        String messageText = update.getCallbackQuery().getData();
+
+        String [] tags = Arrays.stream(messageText.split(":"))
+                .map(String::trim)
+                .toArray(String[]::new);
+
+        String result;
+        if (tags[1].equals("all")) {
+            result = unameAllHost();
+        } else {
+            result = unameSpecificHost(tags[1]);
+        }
+        SendMessage message = new SendMessage();
+        long chatId = update.getCallbackQuery().getMessage().getChatId();
+        message.setChatId(chatId);
+        message.setText(result);
+        return message;
+    }
+
+    private String unameAllHost() {
+       List<SshServer> servers = 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()) {
+            String result = sshService.execute("uname -a", server.get());
+            return server.get().getName() + ": " + (Objects.isNull(result) ? "ошибка при выполнении команды" : result);
+
+        } else {
+            log.error("Ошибка при выполнении команды 'uname'. Искомый сервер (" + serverName + ") не найден");
+            return null;
+        }
+    }
+}

src/main/java/ru/ldeloff/servermonitorbot/util/TelegramBotMenu.java

@@ -1,61 +0,0 @@
-package ru.ldeloff.servermonitorbot.util;
-
-import lombok.extern.slf4j.Slf4j;
-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.ReplyKeyboardMarkup;
-import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.InlineKeyboardButton;
-import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.KeyboardButton;
-import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.KeyboardRow;
-
-
-import java.util.ArrayList;
-import java.util.List;
-
-@Slf4j
-@Component
-public class TelegramBotMenu {
-    private final String STATUS = "Статус";
-    public ReplyKeyboardMarkup initKeyboard()
-    {
-        //Создаем объект будущей клавиатуры и выставляем нужные настройки
-        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));
-        //добавляем лист с одним рядом кнопок в главный объект
-        replyKeyboardMarkup.setKeyboard(keyboardRows);
-        return replyKeyboardMarkup;
-    }
-
-    public SendMessage mainMenu(long chatId) {
-        SendMessage message = new SendMessage();
-        message.setChatId(chatId);
-        message.setText("Choose an option:");
-
-        InlineKeyboardMarkup inlineKeyboardMarkup = new InlineKeyboardMarkup();
-        List<InlineKeyboardButton> keyboardRow = new ArrayList<>();
-
-        InlineKeyboardButton inlineKeyboardButton = new InlineKeyboardButton();
-        inlineKeyboardButton.setText(STATUS);
-        inlineKeyboardButton.setCallbackData("Button \"" + STATUS + "\" has been pressed");
-
-        keyboardRow.add(inlineKeyboardButton);
-
-        List<List<InlineKeyboardButton>> keyboard = new ArrayList<>();
-        keyboard.add(keyboardRow);
-
-        inlineKeyboardMarkup.setKeyboard(keyboard);
-        message.setReplyMarkup(inlineKeyboardMarkup);
-
-        return message;
-    }
-}

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

@@ -0,0 +1,35 @@
+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";
+
+    @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));
+
+        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/UnameChatButtonAggregate.java

@@ -0,0 +1,52 @@
+package ru.ldeloff.servermonitorbot.utils.ui.uname;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
+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.repository.SshRepository;
+import ru.ldeloff.servermonitorbot.service.ssh.SshService;
+import ru.ldeloff.servermonitorbot.utils.ui.UiFormer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Component
+@RequiredArgsConstructor
+public class UnameChatButtonAggregate 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 -> {
+            List<InlineKeyboardButton> keyboardRow = new ArrayList<>();
+            InlineKeyboardButton inlineKeyboardButton = new InlineKeyboardButton();
+            inlineKeyboardButton.setText(sshServer.getName());
+            inlineKeyboardButton.setCallbackData("uname: " + sshServer.getName());
+            keyboardRow.add(inlineKeyboardButton);
+            keyboard.add(keyboardRow);
+        });
+
+        if (sshService.getSshServers().size() > 1) {
+            List<InlineKeyboardButton> keyboardRow = new ArrayList<>();
+            InlineKeyboardButton inlineKeyboardButton = new InlineKeyboardButton();
+            inlineKeyboardButton.setText("Все сервера");
+            inlineKeyboardButton.setCallbackData("uname: all");
+            keyboardRow.add(inlineKeyboardButton);
+            keyboard.add(keyboardRow);
+        }
+
+        inlineKeyboardMarkup.setKeyboard(keyboard);
+        message.setReplyMarkup(inlineKeyboardMarkup);
+        message.setText("Выполнить uname для");
+
+        return message;
+    }
+}