export CLIENT_APP_CRT_NAME=client-cert;
# Пароль, заданный при выпуске клиентского сертификата
# (используется в кач-ве пароля для хранилищ)
export CRT_STORAGES_PASSWORD='changeit';
export RABBIT_GATEWAY_CRT_NAME=rabbit-gw-dev;
export RABBIT_GATEWAY_URL=rabbit-gw-dev.url;
export RABBIT_GATEWAY_PORT=1234;
export ROOT_CRT_NAME=root-cert;

# Извлечь ключ pem и сертификат crt из pfx
openssl pkcs12 -in "${CLIENT_APP_CRT_NAME}".pfx -passin pass:"${CRT_STORAGES_PASSWORD}" -nocerts -nodes -out "${CLIENT_APP_CRT_NAME}".pem;
openssl pkcs12 -in "${CLIENT_APP_CRT_NAME}".pfx -passin pass:"${CRT_STORAGES_PASSWORD}" -clcerts -nokeys -out "${CLIENT_APP_CRT_NAME}".crt;

# Key Store (сертификат приложения)
openssl pkcs12 -export -in "${CLIENT_APP_CRT_NAME}".crt -inkey "${CLIENT_APP_CRT_NAME}".pem \
 -out "${RABBIT_GATEWAY_CRT_NAME}"_key_store.p12 -name "${RABBIT_GATEWAY_CRT_NAME}" -passout pass:"${CRT_STORAGES_PASSWORD}" \
 -CAfile "${ROOT_CRT_NAME}".crt -caname root;

# Trust Store (сертификат шлюза)
keytool -import -alias "${RABBIT_GATEWAY_URL}"_client -file "${CLIENT_APP_CRT_NAME}".crt -keystore "${RABBIT_GATEWAY_CRT_NAME}"_trust_store.jks \
 -noprompt -deststorepass "${CRT_STORAGES_PASSWORD}";
openssl s_client -showcerts -connect "${RABBIT_GATEWAY_URL}":"${RABBIT_GATEWAY_PORT}" -prexit 2>/dev/null | sed -n -e '/BEGIN\ CERTIFICATE/,/END\ CERTIFICATE/ p' \
 | tee "${RABBIT_GATEWAY_URL}".cert \
&& keytool -import -alias "${RABBIT_GATEWAY_URL}"_server -file "${RABBIT_GATEWAY_URL}".cert -keystore "${RABBIT_GATEWAY_CRT_NAME}"_trust_store.jks \
 -noprompt -deststorepass "${CRT_STORAGES_PASSWORD}";

unset CLIENT_APP_CRT_NAME;
unset CRT_STORAGES_PASSWORD;
unset RABBIT_GATEWAY_CRT_NAME;
unset RABBIT_GATEWAY_URL;
unset RABBIT_GATEWAY_PORT;
unset ROOT_CRT_NAME;

ADD app-repository/keystore/rabbit-gw-dev_key_store.p12 /app-in-container/keystore/rabbit-gw-dev_key_store.p12
ADD app-repository/keystore/rabbit-gw-dev_trust_store.jks /app-in-container/keystore/rabbit-gw-dev_trust_store.jks
ENV SSL_KEYSTORE=/app-in-container/keystore/

spring:
  rabbitmq:
    # <-- host, port, username, password
    ssl:
      enabled: true
      keyStore: file:${SSL_KEYSTORE}${RABBIT_SSL_KEY_STORE}
      key-store-password: ${RABBIT_SSL_KEY_STORE_PASSWORD}
      trust-store: file:${SSL_KEYSTORE}${RABBIT_SSL_TRUST_KEY_STORE}
      trust-store-password: ${RABBIT_SSL_TRUST_KEY_STORE_PASSWORD}
  multirabbitmq:
    enabled: true
    connections:
      reserve-gateway:
        # <-- host, port, username, password
        ssl:
          enabled: ${spring.rabbitmq.ssl.enabled}
          keyStore: ${spring.rabbitmq.ssl.keyStore}
          key-store-password: ${spring.rabbitmq.ssl.key-store-password}
          trust-store: ${spring.rabbitmq.ssl.trust-store}
          trust-store-password: ${spring.rabbitmq.ssl.trust-store-password}

static void day1(String puzzleInputUri) throws IOException, InterruptedException {
    Map<String, String> digits = Map.of(
            "1", "one",
            "2", "two",
            "3", "three",
            "4", "four",
            "5", "five",
            "6", "six",
            "7", "seven",
            "8", "eight",
            "9", "nine"
    );
    TreeMap<Integer, String> firstLast = new TreeMap<>();
    var result = client.send(request.uri((URI.create(puzzleInputUri))).build(), HttpResponse.BodyHandlers.ofLines()).body()
            .map(string -> {
                firstLast.clear();
                digits.forEach((digit, numeric) -> {
                        firstLast.put(string.indexOf(digit), digit);
                        firstLast.put(string.lastIndexOf(digit), digit);
                        firstLast.put(string.indexOf(numeric), digit);
                        firstLast.put(string.lastIndexOf(numeric), digit);
                    }
                );
                firstLast.remove(-1); // not matched substrings index
                return firstLast.firstEntry().getValue() + firstLast.lastEntry().getValue();
            })
            .mapToInt(Integer::parseInt)
            .sum();
    System.out.println(result);
}

// Game 1: 3 blue, 4 red; 1 red, 2 green, 6 blue; 2 green
static void day2(String puzzleInputUri) throws IOException, InterruptedException {
    Map<String, Integer> bagOfCubes = Map.of("red", 12, "green", 13, "blue", 14);
    var games = client.send(request.uri((URI.create(puzzleInputUri))).build(),
                    HttpResponse.BodyHandlers.ofLines()).body()
            .map(game -> game.split(":", 2))
            .map(idAndResults -> Map.entry(
                    idAndResults[0].split(" ", 2)[1], // game id
                    idAndResults[1] // results string
            ))
            .map(idAndResults -> Map.entry(idAndResults.getKey(), idAndResults.getValue().split(";")))
            .map(idAndResults -> {
                List<Map<String, Integer>> parsedResults = new ArrayList<>();
                for (String s : idAndResults.getValue()) {
                    Map<String, Integer> cubesCount = new HashMap<>();
                    for (String s1 : s.split(",")) {
                        String[] cubeCount = s1.trim().split(" ", 2);
                        cubesCount.put(cubeCount[1].trim(), Integer.parseInt(cubeCount[0].trim()));
                    }
                    parsedResults.add(cubesCount);
                }
                return Map.entry(idAndResults.getKey(), parsedResults);
            })
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

    var answer1 = games.entrySet().stream()
            .filter(idAndResults -> idAndResults.getValue().stream()
                .flatMap(it -> it.entrySet().stream())
                .noneMatch(result -> result.getValue() > bagOfCubes.get(result.getKey()))
            )
            .mapToInt(idAndResults -> Integer.parseInt(idAndResults.getKey()))
            .sum();

    var answer2 = games.entrySet().stream()
            .map(idAndResults -> Map.entry(
                idAndResults.getKey(),
                idAndResults.getValue().stream()
                    .reduce((m1, m2) -> {
                        Map<String, Integer> minRequired = new HashMap<>();
                        bagOfCubes.keySet().forEach(cube -> minRequired.put(cube,
                            Math.max(m1.getOrDefault(cube, 0),
                                    m2.getOrDefault(cube, 0))
                        ));
                        return minRequired;
                    }).orElseThrow()
                )
            )
            .mapToInt(idAndMinRequired -> idAndMinRequired.getValue().values().stream()
                    .reduce((v1, v2) -> v1 * v2).orElseThrow() // v != 0 ? v : 1
            )
            .sum();

    System.out.println(answer1);
    System.out.println(answer2);
}

static void day3(String puzzleInputUri) throws IOException, InterruptedException {
    Integer emptyCell = (int) '.';
    Integer gearCell = (int) '*';
    List<List<Integer>> scheme = client.send(request.uri((URI.create(puzzleInputUri))).build(),
                    HttpResponse.BodyHandlers.ofLines()).body()
            .map(line -> line.chars().boxed().collect(Collectors.toCollection(ArrayList::new)))
            .peek(chars -> chars.addFirst(emptyCell))
            .peek(chars -> chars.addLast(emptyCell))
            .collect(Collectors.toCollection(ArrayList::new));
    scheme.addFirst(Collections.nCopies(scheme.getFirst().size(), emptyCell));
    scheme.addLast(Collections.nCopies(scheme.getFirst().size(), emptyCell));

    List<Part> parts = new ArrayList<>();
    List<Cell> gears = new ArrayList<>();
    List<Cell> partDigit = new ArrayList<>();
    boolean prevIsDigit = false;
    for (int row = 1; row < scheme.size() - 1; row++) {
        for (int column = 1; column < scheme.get(row).size() - 1; column++) {
            Integer cellValue = scheme.get(row).get(column);
            if (Character.isDigit(cellValue)) {
                partDigit.add(new Cell(new Coord(row, column), cellValue));
                prevIsDigit = true;
            } else if (prevIsDigit) {
                parts.add(new Part(partDigit));
                partDigit.clear();
                prevIsDigit = false;
            }
            if (gearCell.equals(cellValue)) {
                gears.add(new Cell(new Coord(row, column), cellValue));
            }
        }
    }
    var validParts = parts.stream()
            .filter(part -> part.border().stream().anyMatch(
                    c -> !emptyCell.equals(scheme.get(c.row()).get(c.column()))
            )).toList();

    var answer1 = validParts.stream()
            .mapToInt(part -> part.value())
            .sum();
    System.out.println(answer1);

    var answer2 = gears.stream()
            .map(gear -> Map.entry(gear,
                validParts.stream().filter(part -> part.border().contains(gear.coord())).toList()
            ))
            .filter(gearParts -> gearParts.getValue().size() == 2)
            .map(Map.Entry::getValue)
            .mapToInt(gearParts -> gearParts.getFirst().value() * gearParts.getLast().value())
            .sum();
    System.out.println(answer2);
}

public class Card {
    private static final Predicate<String> EMPTY = s -> " ".equals(s) || "".equals(s);
    Integer cardN, winCnt;
    Set<Integer> win, have;
    List<Card> nextCards = new ArrayList<>(); // added for part 2
    public Card(String cardN, String[] win, String[] have) {
        this.cardN = Integer.parseInt(cardN.replaceAll("^Card\\s+", ""));
        this.win = parseNums(win);
        this.have = parseNums(have);
        this.winCnt = (int) this.have.stream().filter(h -> this.win.contains(h)).count();
    }
    void addNext(List<Card> nextCards) { // added for part 2
        this.nextCards.addAll(nextCards);
    }
    Stream<Card> flat() { // added for part 2
        return Stream.concat(Stream.of(this),
                this.nextCards.stream().flatMap(Card::flat));
    }
    private static Set<Integer> parseNums(String[] nums) {
        return Arrays.stream(nums).filter(not(EMPTY)).map(Integer::parseInt)
                .collect(Collectors.toSet());
    }
};

static void day4(String puzzleInputUri) throws IOException, InterruptedException {
    var cards = client.send(request.uri((URI.create(puzzleInputUri))).build(),
                    HttpResponse.BodyHandlers.ofLines()).body()
            .map(it -> it.split(":", 2))
            .map(it -> Map.entry(it[0], it[1].split("\\|", 2)))
            .map(it -> new Card(it.getKey(), it.getValue()[0].split(" "),
                    it.getValue()[1].split(" ")))
            .toList();

    var answer1 = cards.stream()
            .filter(card -> card.winCnt > 0)
            .mapToInt(card -> card.winCnt)
            .mapToDouble(win -> Math.pow(2, (win - 1)))
            .reduce(Double::sum).orElseThrow();
    System.out.println(answer1); // 20117

    var answer2 = IntStream.iterate(cards.size() - 1, i -> i >= 0, i -> i - 1)
            .mapToObj(cards::get)
            .peek(card -> card.addNext(cards.subList(card.cardN, card.cardN + card.winCnt)))
            .flatMap(card -> card.flat())
            .count();
    System.out.println(answer2); // 13768818
}

// https://stackoverflow.com/a/30072617
public static <T> Stream<List<T>> listPartition(@NotNull List<T> source, @Positive int length) {
    requireNonNull(source, "Source list must not be null");
    if (length <= 0) {
        throw new IllegalArgumentException("Partitions length must be greater than zero");
    }
    int size = source.size();
    if (size == 0) {
        return Stream.empty();
    }
    if (size <= length) {
        return Stream.of(source);
    }
    int fullChunks = (size - 1) / length;
    return IntStream.range(0, fullChunks + 1)
        .mapToObj(n -> source.subList(n * length, n == fullChunks ? size : (n + 1) * length));
}

nano /etc/docker/daemon.json

{
  "registry-mirrors": ["https://mirror.gcr.io"]
}

service docker restart

{
"registry-mirrors" : ["https://huecker.io", "https://yandex.cr/mirror/", "https://mirror.gcr.io", "https://ghcr.io", "https://gcr.io", "https://mcr.microsoft.com",  "https://public.ecr.aws", "https://daocloud.io", "https://registry.docker-cn.com", "https://c.163.com", "https://eu-central-1.mirror.aliyuncs.com", "https://docker.mirrors.ustc.edu.cn"]
}

nano /etc/sysconfig/docker

OPTIONS='--selinux-enabled --log-driver=journald --registry-mirror=<MIRROR>'

Книга рассказывает об архитектурных принципах, на которых базируются все современные системы управления базами данных, а также об алгоритмах и структурах данных, которые в них используются. Особое внимание уделено сравнению реализаций одних и тех же подходов в близких по функциональности платформах.