blob: dd300058ccbb2f723582eb79e30f77618dedad3c [file] [log] [blame]
// Copyright (C) 2017 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.gerrit.acceptance.ssh;
import static com.google.common.collect.ImmutableList.toImmutableList;
import static com.google.common.truth.Truth.assertThat;
import static com.google.common.truth.Truth.assertWithMessage;
import com.google.common.base.Splitter;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Streams;
import com.google.common.flogger.FluentLogger;
import com.google.gerrit.acceptance.AbstractDaemonTest;
import com.google.gerrit.acceptance.NoHttpd;
import com.google.gerrit.acceptance.Sandboxed;
import com.google.gerrit.acceptance.UseSsh;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Spliterator;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;
import org.junit.Test;
@NoHttpd
@UseSsh
public class SshCommandsIT extends AbstractDaemonTest {
private static final FluentLogger logger = FluentLogger.forEnclosingClass();
// TODO: It would be better to dynamically generate these lists
private static final ImmutableList<String> COMMON_ROOT_COMMANDS =
ImmutableList.of(
"apropos",
"check-project-access",
"close-connection",
"convert-ref-storage",
"flush-caches",
"gc",
"logging",
"ls-groups",
"ls-members",
"ls-projects",
"ls-user-refs",
"plugin",
"reload-config",
"show-caches",
"show-connections",
"show-queue",
"version");
private static final ImmutableList<String> MASTER_ONLY_ROOT_COMMANDS =
ImmutableList.of(
"ban-commit",
"create-account",
"create-branch",
"create-group",
"create-project",
"index",
"query",
"receive-pack",
"rename-group",
"review",
"sequence",
"set-account",
"set-head",
"set-members",
"set-project",
"set-project-parent",
"set-reviewers",
"set-topic",
"stream-events",
"test-submit",
"migrate-externalids-to-insensitive");
private static final ImmutableList<String> EMPTY = ImmutableList.of();
private static final ImmutableMap<String, List<String>> MASTER_COMMANDS =
ImmutableMap.<String, List<String>>builder()
.put("kill", EMPTY)
.put("ps", EMPTY)
// TODO(dpursehouse): Add "scp" and "suexec"
.put(
"gerrit",
Streams.concat(COMMON_ROOT_COMMANDS.stream(), MASTER_ONLY_ROOT_COMMANDS.stream())
.sorted()
.collect(toImmutableList()))
.put(
"gerrit index",
ImmutableList.of(
"changes", "changes-in-project")) // "activate" and "start" are not included
.put("gerrit logging", ImmutableList.of("ls", "set"))
.put(
"gerrit plugin",
ImmutableList.of("add", "enable", "install", "ls", "reload", "remove", "rm"))
.put("gerrit test-submit", ImmutableList.of("rule", "type"))
.put("gerrit sequence", ImmutableList.of("set", "show"))
.build();
private static final ImmutableMap<String, List<String>> SLAVE_COMMANDS =
ImmutableMap.of(
"kill",
EMPTY,
"gerrit",
COMMON_ROOT_COMMANDS,
"gerrit plugin",
ImmutableList.of("add", "enable", "install", "ls", "reload", "remove", "rm"));
@Test
@Sandboxed
public void sshCommandCanBeExecuted() throws Exception {
testCommandExecution(MASTER_COMMANDS);
restartAsSlave();
testCommandExecution(SLAVE_COMMANDS);
}
private void testCommandExecution(Map<String, List<String>> commands) throws Exception {
for (String root : commands.keySet()) {
List<String> cmds = commands.get(root);
if (cmds.isEmpty()) {
testCommandExecution(root);
} else {
for (String cmd : cmds) {
testCommandExecution(String.format("%s %s", root, cmd));
}
}
}
}
private void testCommandExecution(String cmd) throws Exception {
// We can't assert that adminSshSession.hasError() is false, because using the --help
// option causes the usage info to be written to stderr. Instead, we assert on the
// content of the stderr, which will always start with "gerrit command" when the --help
// option is used.
logger.atFine().log("%s", cmd);
adminSshSession.exec(String.format("%s --help", cmd));
String response = adminSshSession.getError();
assertWithMessage(String.format("command %s failed: %s", cmd, response))
.that(response)
.startsWith(cmd);
}
@Test
public void nonExistingCommandFails() throws Exception {
adminSshSession.exec("gerrit non-existing-command --help");
assertThat(adminSshSession.getError())
.startsWith("fatal: gerrit: non-existing-command: not found");
}
@Test
@Sandboxed
public void listCommands() throws Exception {
adminSshSession.exec("gerrit --help");
List<String> commands = parseCommandsFromGerritHelpText(adminSshSession.getError());
assertThat(commands).containsExactlyElementsIn(MASTER_COMMANDS.get("gerrit")).inOrder();
restartAsSlave();
adminSshSession.exec("gerrit --help");
commands = parseCommandsFromGerritHelpText(adminSshSession.getError());
assertThat(commands).containsExactlyElementsIn(SLAVE_COMMANDS.get("gerrit")).inOrder();
}
@Test
@Sandboxed
public void showConnections() throws Exception {
Spliterator<String> connectionsOutput =
getOutputLines(adminSshSession.exec("gerrit show-connections"));
assertThat(findConnectionsInOutput(connectionsOutput, "user")).hasSize(1);
}
@Test
@Sandboxed
public void cloeConnections() throws Exception {
List<String> connectionsOutput =
findConnectionsInOutput(
getOutputLines(adminSshSession.exec("gerrit show-connections")), "user");
String connectionId =
Splitter.on(" ")
.trimResults()
.omitEmptyStrings()
.split(connectionsOutput.get(0))
.iterator()
.next();
String closeConnectionOutput = adminSshSession.exec("gerrit close-connection " + connectionId);
assertThat(closeConnectionOutput).contains(connectionId);
assertThat(
findConnectionsInOutput(
getOutputLines(adminSshSession.exec("gerrit show-connections")), "user"))
.isEmpty();
}
private List<String> parseCommandsFromGerritHelpText(String helpText) {
List<String> commands = new ArrayList<>();
List<String> lines = Splitter.on("\n").splitToList(helpText);
// Skip all lines including the line starting with "Available commands"
int row = 0;
do {
row++;
} while (row < lines.size() && !lines.get(row - 1).startsWith("Available commands"));
// Skip all empty lines
while (lines.get(row).trim().isEmpty()) {
row++;
}
// Parse commands from all lines that are indented (start with a space)
while (row < lines.size() && lines.get(row).startsWith(" ")) {
String line = lines.get(row).trim();
// Abort on empty line
if (line.isEmpty()) {
break;
}
// Cut off command description if there is one
int endOfCommand = line.indexOf(' ');
commands.add(endOfCommand > 0 ? line.substring(0, line.indexOf(' ')) : line);
row++;
}
return commands;
}
private List<String> findConnectionsInOutput(Spliterator<String> connectionsOutput, String user) {
List<String> connections =
StreamSupport.stream(connectionsOutput, false)
.filter(s -> s.contains("localhost") && s.contains(user))
.collect(Collectors.toList());
return connections;
}
private Spliterator<String> getOutputLines(String output) throws Exception {
return Splitter.on("\n").trimResults().omitEmptyStrings().split(output).spliterator();
}
}