Завдання

Відповідно до номера свого варіанта виконайте завдання обраного рівня складності.

Варіанти

Варіант 1. Мережевий чат

1. Початковий рівень. Створити консольну програму-сервер TCP, яка приймає кількох клієнтів одночасно (задача на кожне з’єднання) і розсилає кожен отриманий рядок усім іншим клієнтам, та програму-клієнт, що надсилає рядки з клавіатури й виводить отримані.

2. Базовий рівень. Створити TCP-сервер і клієнт чату з кадруванням «довжина (4 байти) + JSON» ({"user", "text", "time"}). Сервер перевіряє унікальність імені, виводить журнал підключень, коректно обробляє відключення клієнта й обрив з’єднання (IOException) без зупинки інших сесій.

3. Високий рівень. Створити застосунок TCP-чату chat з командами server --port N і client --host H --port N --name ім’я та опцією --help: сервер розсилає повідомлення клієнтам тієї самої кімнати. Сервер підтримує кімнати (/join, /rooms, /quit), для кожного клієнта має чергу Channel<T> і відключає клієнтів без хартбіту 15 с. Режим client --bots 100 вимірює кількість повідомлень за секунду; помилки – у потік помилок, коди завершення 0/1/2.

Варіант 2. Передавання файлів

1. Початковий рівень. Створити TCP-сервер, який приймає файл (ім’я, розмір, вміст) і зберігає його в теку inbox, та клієнт, що надсилає файл, шлях до якого введено з клавіатури, і виводить кількість переданих байтів.

2. Базовий рівень. Створити клієнт і сервер передавання файлів з хешем SHA-256: клієнт виводить прогрес у відсотках і швидкість (МБ/с), сервер перевіряє хеш і відповідає «OK» або «ПОМИЛКА», вилучаючи пошкоджений файл. Некоректний шлях і недоступний сервер обробляються з повідомленнями.

3. Високий рівень. Створити застосунок передавання файлів через TCP ftx з командами serve тека (приймати файли в теку) і send файл --host H та опціями --resume, --chunk КБ, --help. Після обриву клієнт запитує в сервера розмір уже отриманої частини й докачує файл, хеш SHA-256 перевіряється для всього файла. Програма вимірює швидкість для блоків 4, 64, 1024 КБ і виводить таблицю; коди завершення: 0, 1 – аргументи, 2 – мережа, 3 – хеш не збігся.

Варіант 3. Сервер точного часу

1. Початковий рівень. Створити UDP-сервер, який на кожну дейтаграму відповідає поточним часом UTC у форматі ISO 8601, та клієнт, що надсилає 5 запитів і виводить отриманий час і затримку в мілісекундах.

2. Базовий рівень. Створити UDP-клієнт і сервер часу з нумерацією запитів: клієнт надсилає 20 запитів з таймаутом 500 мс, повторює загублені, відкидає застарілі відповіді, обчислює затримку за формулою $d=(t_4-t_1)-(t_3-t_2)$ і зсув годинника та виводить таблицю, мінімум, медіану й кількість втрат.

3. Високий рівень. Створити застосунок синхронізації часу через UDP timesync з командами server --port N --loss P (сервер відповідає поточним часом UTC, імітуючи втрату P % дейтаграм) і client --host H --count N --interval мс --help. Клієнт нумерує запити, повторює загублені, обчислює затримку $d=(t_4-t_1)-(t_3-t_2)$ і оцінює зсув годинника за вибірками з найменшою затримкою, виводить таблицю й підсумки та пише CSV-файл.

Варіант 4. Онлайн-вікторина

1. Початковий рівень. Створити TCP-сервер вікторини, який надсилає клієнту 5 питань з файлу (по одному рядку) і підраховує правильні відповіді, та клієнт, що відповідає з клавіатури й отримує підсумковий бал.

2. Базовий рівень. Створити TCP-сервер вікторини для кількох гравців одночасно: питання надсилаються всім одночасно, на відповідь 10 с (таймаут CancellationTokenSource), бали нараховуються за швидкість. Після кожного питання всім надсилається таблиця результатів.

3. Високий рівень. Створити застосунок TCP-вікторини quiz з командами host файл.json --port N --players K (сервер з питаннями з файлу) і join --host H --name ім’я (гравець відповідає з клавіатури), опцією --help. Сервер чекає K гравців, веде раунди з таймером (бали за правильність і швидкість), після кожного питання надсилає таблицю результатів, обробляє повторне підключення з тим самим іменем і зберігає результати в JSON.

Варіант 5. Віддалений калькулятор матриць

1. Початковий рівень. Створити gRPC-сервіс з унарним методом Multiply, що приймає дві матриці (repeated double і розміри) та повертає добуток, і консольний клієнт, який множить дві матриці 3×3, введені з клавіатури.

2. Базовий рівень. Створити gRPC-сервіс матриць з методами Multiply, Inverse, Determinant: сервіс повертає InvalidArgument для несумісних розмірів і FailedPrecondition для виродженої матриці; клієнт задає дедлайн 2 с і виводить код статусу та повідомлення.

3. Високий рівень. Створити gRPC-сервіс з методом Multiply, що повертає добуток двох матриць, і застосунок matrix-client з опціями --server, --size n, --deadline мс, --parallel K, --help. Клієнт генерує матриці $n\times n$ з фіксованим зерном, надсилає K одночасних викликів через один GrpcChannel, перевіряє результати локальним множенням і виводить таблицю «K – викликів/с – прискорення» для K = 1, 2, 4, 8, 16.

Варіант 6. Сховище ключ–значення

1. Початковий рівень. Створити TCP-сервер сховища з текстовими командами SET ключ значення, GET ключ, DEL ключ (по рядку) та клієнт, який передає команди з клавіатури й виводить відповіді.

2. Базовий рівень. Створити сервер ключ–значення з власним бінарним протоколом (BinaryWriter: код команди, ключ, значення) і ConcurrentDictionary. Кілька клієнтів працюють одночасно; сервер відповідає кодами OK, NOT_FOUND, ERROR і виводить статистику команд.

3. Високий рівень. Створити TCP-сховище ключ–значення kv з командами server --port N --data файл і bench --host H --clients K --ops N, опцією --help. Сервер обслуговує кількох клієнтів одночасно командами SET, GET, DEL і атомарним INCR, зберігає дані у файл при зупинці й відновлює під час запуску. Режим bench вимірює операції за секунду для K = 1…32 і перевіряє, що після K·N інкрементів лічильник правильний.

Варіант 7. Біржові котирування

1. Початковий рівень. Створити gRPC-сервіс із серверним потоком Subscribe(ticker), який щосекунди надсилає випадкову ціну тикера, та клієнт, що виводить 10 котирувань тикера, введеного з клавіатури.

2. Базовий рівень. Створити gRPC-сервіс котирувань із підпискою на кілька тикерів одночасно (repeated string): сервер надсилає лише зміни понад 0,5 %, клієнт виводить таблицю останніх цін і скасовує підписку клавішею Esc; невідомий тикер – NotFound.

3. Високий рівень. Створити gRPC-сервіс котирувань із серверним потоком підписки на тикери (сервер щосекунди надсилає випадкові ціни) і клієнт quotes з опціями --server, --tickers A,B,C, --duration с, --clients K, --help. Клієнт виводить мінімум, максимум і середню ціну кожного тикера, після обриву потоку перепідключається з експоненційною затримкою (до 5 спроб); здатність сервера обслуговувати 100 одночасних підписок перевіряється режимом --clients 100.

Варіант 8. Телеметрія автомобілів

1. Початковий рівень. Створити gRPC-сервіс з клієнтським потоком Upload(stream Reading) (швидкість, координати, час), який повертає кількість отриманих записів і середню швидкість, та клієнт, що надсилає 100 імітованих записів.

2. Базовий рівень. Створити gRPC-сервіс телеметрії, який для кожного автомобіля (ідентифікатор у метаданих) обчислює пробіг, максимальну й середню швидкість; клієнт читає записи з CSV-файлу і передає їх потоком, некоректні рядки пропускає з повідомленням.

3. Високий рівень. Створити застосунок telemetry з gRPC-сервісом телеметрії автомобілів: клієнтський потік записів (ідентифікатор авто, швидкість, координати, час), команди server і simulate --cars K --points N, опція --help. K імітованих автомобілів одночасно передають потоки; сервер потокобезпечно агрегує пробіг, максимальну й середню швидкість і за викликом Report повертає таблицю; клієнт вимірює час передавання для K = 1, 4, 16, 64 і перевіряє суми записів.

Варіант 9. Розподілені робітники Монте-Карло

1. Початковий рівень. Створити gRPC-сервіс-робітник з методом EstimatePi(points, seed), який обчислює кількість точок у колі, та клієнт-координатор, що викликає його 4 рази з різними зернами й виводить оцінку числа π.

2. Базовий рівень. Створити gRPC-сервіс-робітник з методом EstimatePi(points, seed) (кількість випадкових точок у колі) і координатор, який розподіляє 10^8 точок між кількома робітниками (адреси з файлу) одночасними викликами з дедлайном, повторює виклик на іншому робітнику в разі Unavailable і виводить оцінку π, похибку та час.

3. Високий рівень. Створити застосунок mc для оцінки π методом Монте-Карло на gRPC-робітниках з командами worker --port N (метод EstimatePi(points, seed) рахує точки в колі) і coordinate --workers файл --points N --chunks K --help. Координатор ділить точки на K частин, балансує їх за швидкістю відповіді робітників, виводить оцінку π, похибку й таблицю прискорення для 1, 2, 4 робітників.

Варіант 10. Бронювання бібліотечних книг

1. Початковий рівень. Створити gRPC-сервіс бібліотеки з унарними методами ListBooks і Reserve(bookId, reader) та клієнт, який виводить перелік книг і бронює книгу, номер якої введено з клавіатури.

2. Базовий рівень. Створити gRPC-сервіс бронювання, де кожна книга має обмежену кількість примірників: одночасні бронювання синхронізуються, повторне бронювання повертає AlreadyExists, відсутність примірників – ResourceExhausted. Клієнт запускає 20 одночасних бронювань і виводить підсумки.

3. Високий рівень. Створити gRPC-сервіс бронювання бібліотечних книг (обмежена кількість примірників) і застосунок library з командами server --data books.json і client reserve|return|list, опціями --reader, --request-id, --help. Операції ідемпотентні за ідентифікатором запиту (повтор не створює другого бронювання), стан зберігається у файл; тестовий режим надсилає кожен запит двічі й перевіряє залишки примірників.

Варіант 11. Гра «Хрестики-нулики»

1. Початковий рівень. Створити TCP-сервер, який грає з клієнтом у хрестики-нулики (сервер ходить у випадкову вільну клітинку), та клієнт, що вводить ходи з клавіатури й виводить поле після кожного ходу.

2. Базовий рівень. Створити gRPC-сервіс гри для двох гравців із двонаправленим потоком Play: сервер поєднує гравців у пари, перевіряє правильність і черговість ходів, надсилає обом стан поля й результат партії.

3. Високий рівень. Створити мережеву гру «хрестики-нулики» ttt (gRPC, двонаправлений потік ходів) з командами server і play --name ім’я --bot, опцією --help. Сервер поєднує гравців у пари, перевіряє ходи, веде кілька партій одночасно, обробляє відключення гравця (поразка через 30 с) і зберігає рейтинг у файл; режим --bot запускає 50 партій ботів і виводить статистику виграшів і середній час ходу.

Варіант 12. Моніторинг серверів

1. Початковий рівень. Створити програму-агента, яка щосекунди надсилає UDP-хартбіт з іменем вузла, та програму-монітор, що виводить час останнього хартбіту кожного вузла.

2. Базовий рівень. Створити UDP-монітор, який позначає вузол «недоступним», якщо хартбітів немає понад 3 с, і «знову доступним» після відновлення; агенти передають навантаження процесора й пам’яті, монітор оновлює таблицю кожні 2 с.

3. Високий рівень. Створити застосунок моніторингу вузлів через UDP-хартбіти monitor з командами agent --name --interval мс --loss P (надсилає нумеровані хартбіти, імітуючи втрату P %) і watch --timeout мс --log файл, опцією --help. Монітор виявляє відмови за пропуском N хартбітів, рахує втрати пакетів за номерами, пише журнал подій CSV і виводить для кожного вузла доступність у відсотках.

Варіант 13. Прогноз погоди

1. Початковий рівень. Створити gRPC-сервіс з унарним методом GetForecast(city), що повертає імітований прогноз на 3 дні, та клієнт, який виводить прогноз для міста, введеного з клавіатури.

2. Базовий рівень. Створити gRPC-сервіс прогнозу з кешем на 60 с: повільне «джерело» імітується затримкою 2 с, клієнт передає в метаданих client-id, сервер рахує запити кожного клієнта; клієнт виводить час виклику з кешем і без.

3. Високий рівень. Створити gRPC-сервіс прогнозу погоди GetForecast(city) з кешем (повільне джерело імітується затримкою) і клієнт weather з опціями --server, --cities файл, --parallel K, --deadline мс, --help. Сервер уникає одночасних повторних звернень до джерела для одного міста (одна задача на місто), клієнт виводить таблицю «місто – час – з кешу», кількість DeadlineExceeded і пропускну здатність для K = 1…16.

Варіант 14. Шкільний журнал

1. Початковий рівень. Створити gRPC-сервіс журналу з методами AddGrade(student, subject, grade) і GetGrades(student) та клієнт, який додає 3 оцінки та виводить оцінки учня.

2. Базовий рівень. Створити gRPC-сервіс журналу з клієнтським потоком UploadGrades, що приймає оцінки з CSV-файлу, перевіряє діапазон 1–12 і повертає кількість прийнятих і відхилених записів з номерами рядків; метод GetAverage повертає середній бал з предмета.

3. Високий рівень. Створити gRPC-сервіс шкільного журналу оцінок і застосунок journal з командами server --data файл, upload файл.csv (клієнтський потік оцінок, перевірка 1–12), report --class 10-А, опцією --help. Сервер зберігає дані у файл, підтримує одночасне завантаження від кількох вчителів, звіт повертає серверним потоком; клієнт виводить таблицю середніх балів і зберігає її в CSV.

Варіант 15. Відеоспостереження (кадри-імітація)

1. Початковий рівень. Створити TCP-клієнт «камеру», яка надсилає 100 кадрів по 50 КБ (випадкові байти з префіксом довжини), та сервер, що приймає кадри й виводить їх кількість і загальний обсяг.

2. Базовий рівень. Створити TCP-сервер, що приймає кадри від кількох камер одночасно, для кожної камери обчислює кадри за секунду й пропускну здатність (МБ/с) і виводить таблицю щосекунди; камера задає частоту кадрів і їх розмір.

3. Високий рівень. Створити застосунок cams з командами server і camera --id --fps --size КБ --count, опцією --help: імітовані камери надсилають TCP-серверу кадри (випадкові байти з префіксом довжини). Сервер зберігає лише останні кадри кожної камери (кільцевий буфер), відкидає кадри повільних споживачів, вимірює пропускну здатність для 1, 4, 16 камер і виводить таблицю з відсотком відкинутих кадрів.

Варіант 16. Пошук у каталозі товарів

1. Початковий рівень. Створити gRPC-сервіс з методом Search(query), який повертає товари з JSON-файлу, назва яких містить рядок, та клієнт, що виводить знайдені товари.

2. Базовий рівень. Створити gRPC-сервіс пошуку з пагінацією (page_size, page_token) і сортуванням за ціною; клієнт виводить сторінки по черзі за натисканням Enter і перевіряє некоректний токен сторінки (InvalidArgument).

3. Високий рівень. Створити gRPC-сервіс пошуку товарів за назвою в каталозі з JSON-файлу і клієнт catalog з опціями --server, --query, --min-price, --max-price, --stream, --help. Сервер віддає великі результати серверним потоком і припиняє роботу при скасуванні (токен виклику); клієнт скасовує пошук клавішею Esc і виводить кількість отриманих товарів і час до першого результату.

Варіант 17. Лічильник відвідувачів

1. Початковий рівень. Створити gRPC-сервіс з методами Visit(page) і GetCount(page) та клієнт, який реєструє 10 відвідувань і виводить лічильник.

2. Базовий рівень. Створити gRPC-сервіс лічильника, в якому Visit приймає ідентифікатор запиту: повтори з тим самим ідентифікатором не збільшують лічильник. Клієнт імітує втрату відповідей, повторюючи кожен виклик до 3 разів, і перевіряє, що лічильник дорівнює кількості відвідувань.

3. Високий рівень. Створити gRPC-сервіс лічильника відвідувань сторінок з ідемпотентним Visit (ідентифікатор запиту) і клієнт visits з опціями --server, --clients K, --visits N, --duplicate P (частка повторних викликів), --help. Сервер зберігає виконані ідентифікатори з терміном життя; клієнт виконує K×N відвідувань паралельно й перевіряє лічильник (код завершення 3 у разі розбіжності).

Варіант 18. Групова розсилка оголошень

1. Початковий рівень. Створити програму, що надсилає рядок, введений з клавіатури, на групову адресу 239.0.0.222 (порт 5060), та програму-приймач, яка приєднується до групи й виводить оголошення з адресою відправника.

2. Базовий рівень. Створити групову розсилку з нумерацією дейтаграм: приймач виявляє пропущені й дубльовані номери, виводить статистику втрат, а відправник надсилає задану кількість оголошень із заданим інтервалом.

3. Високий рівень. Створити застосунок mcast з командами send --group --port --count --interval --size і listen --group --port --report с, опцією --help. Приймач виводить щосекундну таблицю «відправник – отримано – втрачено – не по порядку», перевіряє розмір дейтаграм (помилка понад 65 507 байтів) і коди завершення 0/1/2.

Варіант 19. Розподілене сортування

1. Початковий рівень. Створити TCP-сервер-сортувальник, який приймає масив цілих чисел (кількість і значення) і повертає його відсортованим, та клієнт, що надсилає 1000 випадкових чисел і перевіряє результат.

2. Базовий рівень. Створити TCP-сервер-сортувальник, який приймає масив цілих чисел і повертає його відсортованим, та координатор, який ділить масив з 10^6 випадкових чисел на частини, одночасно надсилає їх кільком сортувальникам (адреси з аргументів), зливає відсортовані частини, перевіряє результат порівнянням з Array.Sort і виводить час кожного етапу.

3. Високий рівень. Створити застосунок розподіленого сортування dsort з командами worker --port (TCP-сервер сортує отриману частину) і sort --input файл --workers H1,H2 --help (координатор ділить числа з файлу між робітниками й зливає результати). Дані передаються двійковими кадрами, у разі відмови робітника його частина передається іншому; координатор виводить таблицю «робітники – час, с – прискорення» для 1, 2, 4 робітників і зберігає результат у файл.

Варіант 20. Медичні показники пацієнтів

1. Початковий рівень. Створити gRPC-сервіс з методами AddMeasurement(patient, pulse, pressure) і GetLast(patient) та клієнт, що додає показники з клавіатури й виводить останні.

2. Базовий рівень. Створити gRPC-сервіс медичних показників пацієнтів (AddMeasurement(patient, pulse, pressure), GetLast(patient)) із серверним перехоплювачем, який записує в журнал метод, тривалість і код статусу кожного виклику та перевіряє токен у метаданих authorization; виклики без токена отримують Unauthenticated. Клієнт додає показники й виводить останні.

3. Високий рівень. Створити gRPC-сервіс медичних показників пацієнтів (пульс, тиск) і застосунок health з командами server --tokens файл і client --token --patient, опцією --help. Сервер перевіряє токен у метаданих, серверний потік Watch надсилає тривоги при виході пульсу за межі; клієнтський перехоплювач додає токен і повторює виклики з кодом Unavailable. Журнал викликів виводиться у файл, недійсний токен дає код завершення 4.

Варіант 21. Таксі-диспетчер

1. Початковий рівень. Створити gRPC-сервіс з методами UpdatePosition(driver, x, y) і FindNearest(x, y) та клієнт, який реєструє трьох водіїв і шукає найближчого до введеної точки.

2. Базовий рівень. Створити gRPC-сервіс диспетчера з двонаправленим потоком: водії надсилають позиції щосекунди, сервер надсилає водію замовлення; клієнт-диспетчер створює замовлення, яке отримує найближчий вільний водій.

3. Високий рівень. Створити gRPC-сервіс таксі-диспетчера і застосунок taxi з командами server, drivers --count K (імітація руху водіїв з оновленням позицій) і orders --count N, опцією --help. Сервер потокобезпечно зберігає позиції, призначає замовлення найближчому вільному водієві, виявляє водіїв без оновлень понад 5 с, виводить середній час призначення та кількість оброблених оновлень за секунду для K = 10, 100, 1000.

Варіант 22. Пропускна система офісу

1. Початковий рівень. Створити TCP-клієнт «турнікет», який надсилає подію проходу (номер картки, напрямок, час), та сервер, що дописує події у файл журналу й відповідає «дозволено» або «заборонено» за списком карток.

2. Базовий рівень. Створити TCP-сервер пропускної системи для кількох турнікетів одночасно: сервер перевіряє картку й повторний вхід без виходу, потокобезпечно пише журнал, а на команду REPORT повертає список працівників у будівлі.

3. Високий рівень. Створити TCP-пропускну систему офісу access з командами server --cards файл --log файл (перевіряє картки, пише журнал проходів) і gate --id --events файл (турнікет надсилає події «картка, напрямок, час» з файлу), опцією --help. Турнікет буферизує події при недоступності сервера й надсилає їх після відновлення без дублікатів; сервер виводить звіт робочого часу працівників.

Варіант 23. Порівняння протоколів

1. Початковий рівень. Створити програму, яка вимірює час 10 000 послідовних запитів «ехо» до TCP-сервера в тому самому процесі й виводить середню затримку та кількість запитів за секунду.

2. Базовий рівень. Створити програму, що порівнює виклик «додати два числа» через TCP-сокет із кадрами JSON і через gRPC на localhost: прогрів, 10 000 викликів, медіана, 99-й перцентиль і пропускна здатність; результати виводяться таблицею.

3. Високий рівень. Створити застосунок rpcbench, що порівнює протоколи віддаленого виклику «ехо» (сервер і клієнт в одному процесі на localhost) з опціями --protocols tcp,grpc,rest, --size байти, --clients K, --duration с, --help. Для кожного протоколу й розміру повідомлення (10 Б, 1 КБ, 100 КБ) вимірюються затримка (медіана, 99-й перцентиль) і пропускна здатність; результати виводяться таблицею й зберігаються в CSV.

Варіант 24. Аукціон у реальному часі

1. Початковий рівень. Створити gRPC-сервіс аукціону з методом PlaceBid(lot, user, amount), який приймає ставку лише вищу за поточну, та клієнт, що робить ставки з клавіатури.

2. Базовий рівень. Створити gRPC-сервіс аукціону із серверним потоком WatchLot, який надсилає учасникам нові ставки й повідомлення про завершення лота за таймером; одночасні ставки синхронізуються, відхилені ставки повертають FailedPrecondition.

3. Високий рівень. Створити gRPC-сервіс аукціону (ставки на лоти, серверний потік нових ставок) і застосунок auction з командами server --lots файл і bot --user --budget --strategy, опцією --help. Сервер приймає лише вищі ставки, продовжує лот на 10 с після пізньої ставки; 50 ботів торгуються одночасно, після завершення виводиться таблиця «лот – переможець – ціна – кількість ставок» і перевіряється, що жодна ставка не втрачена.

Варіант 25. Хмарний блокнот

1. Початковий рівень. Створити gRPC-сервіс нотаток з методами Save(id, text) і Load(id) та клієнт, що зберігає й завантажує нотатку, текст якої введено з клавіатури.

2. Базовий рівень. Створити gRPC-сервіс нотаток із номером версії: Save приймає очікувану версію і повертає Aborted, якщо нотатку змінив інший клієнт; клієнт у разі конфлікту завантажує нову версію й показує обидва тексти.

3. Високий рівень. Створити gRPC-сервіс нотаток із версіями (збереження з очікуваною версією) і застосунок notes з командами server --data тека, edit id, sync тека, опцією --help. Синхронізація порівнює версії локальних файлів і сервера, конфлікти зберігає як окремі файли, серверний потік Changes повідомляє клієнтів про зміни; виводиться таблиця синхронізованих, завантажених і конфліктних нотаток.

Варіант 26. Парковка міста

1. Початковий рівень. Створити програму-датчик, яка надсилає UDP-дейтаграму «місце зайняте/вільне», та сервер, що веде стан місць і виводить кількість вільних місць після кожної зміни.

2. Базовий рівень. Створити сервер парковки, який приймає UDP-події від датчиків і водночас обслуговує TCP-запити водіїв «вільні місця в зоні»; стан місць зберігається потокобезпечно, повторні й застарілі події (за номером) ігноруються.

3. Високий рівень. Створити застосунок міської парковки parking з командами server --zones файл (приймає UDP-події датчиків «місце зайняте/вільне» й обслуговує TCP-запити водіїв), sensors --count N --rate подій/с і driver --zone (запит вільних місць у зоні), опцією --help. Сервер виявляє датчики без подій понад 30 с, виводить щохвилинну статистику зайнятості, а навантажувальний режим вимірює кількість оброблених подій за секунду для N = 100, 1000, 10 000.

Варіант 27. Розподілене обчислення хешів

1. Початковий рівень. Створити gRPC-сервіс-робітник з методом Hash(data), який повертає SHA-256, та клієнт, що обчислює хеші трьох файлів через сервіс і порівнює їх з локальним обчисленням.

2. Базовий рівень. Створити gRPC-сервіс-робітник з методом Hash(data), що повертає SHA-256 блоку, і координатор, який розсилає блоки файлу кільком робітникам одночасно (обмеження кількості викликів SemaphoreSlim), збирає хеші блоків у порядку номерів і виводить загальний хеш-рядок та час порівняно з одним робітником.

3. Високий рівень. Створити застосунок розподіленого хешування файлів hashpool з командами worker --port --threads (gRPC-робітник обчислює SHA-256 блоків) і run --workers файл --block МБ --help (координатор ділить файл на блоки). Координатор балансує блоки за довжиною черги робітників, повторює блоки робітника, що відмовив, перевіряє результат з локальним обчисленням і виводить таблицю «робітники – МБ/с – прискорення».

Варіант 28. Спортивні трансляції

1. Початковий рівень. Створити gRPC-сервіс із серверним потоком Follow(match), який надсилає події матчу з файлу з паузами, та клієнт, що виводить події з хвилиною матчу.

2. Базовий рівень. Створити gRPC-сервіс трансляцій, у якому клієнт після обриву з’єднання перепідключається й передає номер останньої отриманої події, а сервер продовжує з наступної; клієнт виводить рахунок після кожного гола.

3. Високий рівень. Створити gRPC-сервіс спортивних трансляцій (серверний потік подій матчу з файлів) і застосунок live з командами server --matches тека і watch --match --reconnect N, опцією --help. Сервер обслуговує сотні підписників через черги Channel<T> і після перепідключення продовжує з події, наступної за останньою отриманою; клієнт імітує N обривів і перевіряє відсутність пропусків і дублікатів.

Варіант 29. Проксі-сервер

1. Початковий рівень. Створити TCP-проксі, який приймає з’єднання на одному порту й пересилає байти на задану адресу та порт в обидва боки (CopyToAsync), виводячи підключення клієнтів.

2. Базовий рівень. Створити TCP-проксі для кількох клієнтів одночасно, який рахує передані байти в кожному напрямку, закриває обидва з’єднання, коли одна сторона закрилася, і пише журнал «клієнт – ціль – байти – тривалість».

3. Високий рівень. Створити застосунок tcpproxy з опціями --listen порт, --target host:port, --max-clients N, --idle-timeout с, --log файл, --help. Проксі обмежує кількість з’єднань, закриває неактивні, виводить щосекундну пропускну здатність і перевіряється передаванням файлу через проксі з порівнянням хешів.

Варіант 30. Сервіс перекладу словників

1. Початковий рівень. Створити gRPC-сервіс з методом Translate(word, direction) на основі словника з файлу та клієнт, який перекладає слово, введене з клавіатури.

2. Базовий рівень. Створити gRPC-сервіс перекладу з увімкненим gRPC reflection і методом TranslateText (двонаправлений потік слів); підготувати файл команд grpcurl для переліку сервісів, опису методів і виклику перекладу та звіт з їх виводом.

3. Високий рівень. Створити gRPC-сервіс перекладу слів за словниками з файлів і застосунок dict з командами server --dicts тека і translate --from --to --file, опцією --help. Сервер повертає NotFound для невідомої мовної пари, клієнт перекладає текст файлу пакетами слів паралельно й виводить переклад і час для 1, 2, 4 потоків.

Порядок виконання та захисту роботи

1. Опрацювати теоретичні відомості та приклади розв’язання завдань.
2. Для свого варіанта скласти схему взаємодії: учасники, транспорт (TCP, UDP або gRPC), формат повідомлень або файл .proto, типи викликів, таймаути й дедлайни, коди помилок.
3. Створити в JetBrains Rider рішення .NET 10 з окремими проєктами сервера й клієнта (для gRPC – спільний файл .proto); сервер і клієнти запускати на localhost з різними портами.
4. Реалізувати завдання обраного рівня: асинхронне обслуговування кількох клієнтів, коректне закриття з’єднань, обробку SocketException / RpcException, синхронізацію спільного стану сервера.
5. Перевірити сценарії успіху, розриву з’єднання, недоступного сервера та перевищення таймауту; переконатися командою Get-NetTCPConnection або ss, що сервер слухає потрібний порт, gRPC-сервіс перевірити через grpcurl або HTTP Client Rider.
6. Продемонструвати роботу програми викладачеві, пояснити програмний код і відповісти на контрольні питання.