Пакеты time, context. Отмена операций и управление временем выполнения

Вы встречаетесь с хозяином апартаментов и получаете ключи.

Саша

Вот и заселились — напишу Лизе, что мы успешно добрались. Здесь уютно. Даже кухня есть. Но сегодня предлагаю заказать доставку — что скажешь?

Да, выходить куда-то уже лень. Пойду разложу вещи в своей комнате.

Саша

Окей, а я пока что-нибудь закажу. Коллега хороший сервис посоветовал.

Ого, ты и продуктов купил? Будешь готовить?

Саша

У меня есть авторский рецепт немецкого штруделя — ум отъешь!

Ммм, это я с удовольствием отведаю.

Алиса

Ум?

Ха-ха, Алиса, не придирайся. Сейчас мне достаточно бутербродов.

Саша

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

В предыдущих спринтах вы узнали, как создавать HTTP-сервер, использовать структурные теги и сериализаторы, изучили сжатие данных и работу с файлами. Настала очередь пакетов time и context стандартной библиотеки Go.

Первый пакет предоставляет функции для операций с датой и временем. Он позволяет получить текущее время и узнать любую дату, например какое число будет через n дней. Ещё благодаря этому пакету можно создать таймер, который будет напоминать, что пора сделать паузу в работе. И это далеко не все возможности.

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

Другой пакет, который вы изучите в этой теме, — context. Без него не обходится ни один серьёзный проект. Пакет context даёт возможность установить дополнительные признаки для завершения работы горутины — например, когда пользователь отменил запущенную задачу или истекло время ожидания соединения с сервером.

С помощью этого пакета можно установить дедлайн или максимальное время выполнения горутины, а также сообщить о прекращении её работы из других потоков. На примере пакета context вы увидите, как могут применяться на практике функции для работы со временем.

Подробно о горутинах расскажем в теме, посвящённой многопоточности. А пока вы узнаете:

как работать со временем, интервалами и часовыми поясами в Go;
как приостанавливать работу горутины, запускать её несколько раз через определённые промежутки;
как преобразовывать дату и время в строку в соответствии с нужным форматом и конвертировать обратно;
как создавать и использовать context для отмены исполнения ветвей программы.

Саша

Немного подкрепились — теперь можно поработать. Сейчас возьму ноутбук, и начнём урок.

Время: даты, интервалы, таймеры

Почти в любом проекте нужно считать продолжительность выполнения кода, ожидать определённого события в программе или просто выводить время в логах. В Go за это отвечает пакет time. Он содержит:

тип Time и методы для работы с датой и временем;
тип Duration и методы для работы с интервалами;
типы Timer, Ticker и функции для работы с таймерами;
тип Location и методы для работы с часовыми поясами.

Для начала расскажем, как получить значения текущих даты и времени. Предположим, нужно зафиксировать время наступления события или определённого действия. Для этого используем функцию time.Now(), которая возвращает переменную типа Time:

GO
package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    fmt.Println(now)
} 

Программа выведет текущее время в таком формате: 2021-11-10 18:48:38.08749 +0300 MSK m=+0.000092583. Тип Time реализует интерфейс fmt.Stringer, поэтому функция fmt.Println() выводит время в виде строки.

Кроме даты и времени, в структуре Time хранится информация о часовом поясе — по умолчанию это часовой пояс операционной системы, в которой запущен код. Для переменной типа Time можно вызвать множество методов, чтобы работать с содержащимся в ней временем.

Для установки произвольных значений даты и времени воспользуемся функцией time.Date():

GO
func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time 

Получим такой результат:

GO
package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Date(2003, time.May, 1, 7, 1, 24, 0, time.UTC)
    fmt.Println(t)
} 

Форматирование даты и времени

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

Вот список основных обозначений в макете:

1 — месяц;
2 — день;
3, 15 — час в 12- и 24-часовом формате соответственно;
4 — минуты;
5 — секунды;
06, 2006 — год;
-0700 — часовой пояс;
pm, PM — время суток;
MST — аббревиатура часового пояса.

Чаще всего к цифре месяца, дня, часа, минуты и секунды добавляют ноль, чтобы значение занимало два символа.

Преобразовать время в строку требуемого формата можно методом Format(). Он возвращает текстовое представление времени в соответствии с переданным макетом:

GO
func (t Time) Format(layout string) string 

Для сравнения преобразуем в строки разного формата одно и то же время. Например, 1 мая 2003 года 17:01:21:

GO
package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Date(2003, time.May, 1, 17, 1, 21, 0, time.UTC)
    fmt.Println("Сложно воспринимать: ", t.Format("2.1.06 3:4:5 PM"))
    fmt.Println("Привычный для нас формат: ", t.Format("02.01.06 15:04:05"))
} 

Программа выведет:

TXT

Сложно воспринимать:  1.5.03 5:1:21 PM
Привычный для нас формат:  01.05.03 17:01:21

Если ко дню добавить слева два нуля или два символа подчёркивания (__), то программа выведет день относительно начала года — в формате трёх символов с нулями или пробелами:

GO
package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Date(2003, time.May, 1, 17, 1, 21, 0, time.UTC)
    fmt.Printf("%s — это %s-й день в году", t.Format("02.01.06"), t.Format("__2"))
} 

Получим:

TXT

01.05.03 — это 121-й день в году

Чтобы запомнить, чему соответствуют числа в макете формата времени, можно использовать мнемонические представления:

TXT

01/02 03:04:05PM '06 -0700
MM/DD HH:MM:SSPM 'YY -ZONE

Также есть дополнительные обозначения:

Jan, January — месяц в виде строки на английском;
Mon, Monday — день в виде строки на английском;
.0-000000000, .9-999999999 — доли секунды, будет выводиться столько цифр, сколько указано;
-0700, -07:00, -07, Z0700, Z07:00, Z07 — часовой пояс;
MST — аббревиатура часового пояса.

Вот некоторые константы пакета time с готовыми макетами:

Константа	Макет	Пример результата
UnixDate	`Mon Jan _2 15:04:05 MST 2006`	`Thu May 1 17:01:21 UTC 2003`
RFC822	`02 Jan 06 15:04 MST`	`01 May 03 17:01 UTC`
RFC850	`Monday, 02-Jan-06 15:04:05 MST`	`Thursday, 01-May-03 17:01:21 UTC`
RFC1123	`Mon, 02 Jan 2006 15:04:05 MST`	`Thu, 01 May 2003 17:01:21 UTC`
RFC3339	`2006-01-02T15:04:05Z07:00`	`2003-05-01T17:01:21Z`

Саша

А ещё время можно вывести в формате 2006-01-02 15:04:05.999999999 -0700 MST. Для этого достаточно воспользоваться методом (t Time) String() string.

Хм, интересно.

Саша

Дам тебе задание, а сам пока тесто для штруделя замешаю.

Задание 1/6

Обычно в компаниях для упрощения чтения и парсинга логов стандартизируют формат логирования. В том числе стандартизируют формат вывода времени. Представьте, что вы начали писать свой сервис и ваша задача — вывести время в формате, принятом в компании.

Выведите на экран текущее время в формате Sun, 19 Sep 2021 15:42:00 MSK: день недели в краткой форме, число в виде двух цифр, месяц в краткой форме, год в виде четырёх цифр, часы в 24-часовом формате, минуты и секунды в виде двух цифр, аббревиатура часового пояса.

GO
package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    // допишите код здесь
    // ...
} 

Готово

GO
func main() {
    now := time.Now()
    fmt.Println(now.Format(time.RFC1123))
    // или
    // fmt.Println(now.Format("Mon, 02 Jan 2006 15:04:05 MST"))
} 

Парсинг даты и времени

Допустим, программа получила значения даты и времени в виде строки. Чтобы работать дальше с этим временем, нужно преобразовать строку в переменную типа Time. Это можно сделать функцией Parse():

GO
func Parse(layout, value string) (Time, error) 

Функция Parse() позволяет получить время из строки, но для этого нужно знать макет, который соответствует данному строковому представлению:

GO
package main

import (
    "fmt"
    "time"
)

func parseTime(layout, value string) {
    t, err := time.Parse(layout, value)
    if err != nil {
        panic(err)
    }
    fmt.Println(t.Format(`02.01.06 15:04:05`))
}

func main() {
    parseTime(time.UnixDate, "Tue Jun 1 22:16:03 MSK 2022")
    parseTime("01/02/2006 15:04:05", "01/26/2023 14:43:00")
} 

Получим такой результат:

TXT

01.06.22 22:16:03
26.01.23 14:43:00

Задание 2/6

Оказалось, что один из сторонних сервисов, взаимодействующих с вашим, передаёт время в виде строки другого формата. Ваша задача — достать объект типа Time из строки 2021-09-19T15:59:41+03:00 и вывести его в консоль.

GO
package main

import (
    "fmt"
    "time"
)

func main() {
    currentTimeStr := "2021-09-19T15:59:41+03:00"
    // допишите код
    // ...
} 

Готово

GO
func main() {
    currentTimeStr := "2021-09-19T15:59:41+03:00"
    currentTime, err := time.Parse(time.RFC3339, currentTimeStr)
    // или
    // currentTime, err := time.Parse("2006-01-02T15:04:05Z07:00", currentTimeStr)
    if err != nil {
        panic(err)
    }
    fmt.Println(currentTime)
} 

Интерфейсы типа Time

Так как у типа Time есть метод String(), он реализует интерфейс fmt.Stringer. Благодаря этому тип Time можно выводить в консоль и преобразовывать в строку.

Кроме fmt.Stringer, тип Time реализует следующие интерфейсы:

encoding.BinaryMarshaler;
encoding.BinaryUnmarshaler;
json.Marshaler;
json.Unmarshaler;
encoding.TextMarshaler;
encoding.TextUnmarshaler.

Тип Time может участвовать в преобразовании структуры в двоичное, текстовое или JSON-представление. По умолчанию для текстового и JSON-преобразования используется макет time.RFC3339.

Из значения типа Time можно получить год, месяц, число, день недели, время, часовой пояс и timestamp с помощью одноимённых методов. Наглядно это можно увидеть на примере:

GO
package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    fmt.Println("Год:", now.Year())
    fmt.Println("Месяц:", now.Month())
    fmt.Println("Число:", now.Day())
    fmt.Println("День недели:", now.Weekday())
    hour, min, sec := now.Clock()
    fmt.Printf("Время: %d:%d:%d\n", hour, min, sec)
    fmt.Println("Часовой пояс:", now.Location())
    fmt.Println("timestamp в секундах:", now.Unix())
    fmt.Println("timestamp в наносекундах:", now.UnixNano())
} 

Программа выведет:

Год: 2021
Месяц: October
Число: 17
День недели: Sunday
Время: 22:41:8
Часовой пояс: Local
timestamp в секундах: 1634499668
timestamp в наносекундах: 1634499668786207000

Значения времени можно сравнивать между собой с помощью методов Equal(), After() и Before():

GO
// Equal проверяет, равны ли два момента времени.
func (t Time) Equal(u Time) bool

// After проверяет, наступил ли момент времени t после u.
func (t Time) After(u Time) bool

// Before проверяет, наступил ли момент времени t перед u.
func (t Time) Before(u Time) bool 

Задание 3/6

В предыдущем задании вы получили время из строки. Теперь нужно понять, отличается ли время, которое вам передали, от текущего. Сравните текущее время с полученным результатом, используя методы Equal(), After() и Before().

GO
package main

import (
    "fmt"
    "log"
    "time"
)

func main() {
    currentTimeStr := "2021-09-19T15:59:41+03:00"
    currentTime, err := time.Parse(time.RFC3339, currentTimeStr)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(currentTime)

    now := time.Now()

    fmt.Println("Is", now, "before", currentTime, "? Answer:", now.Before(currentTime))
    // добавьте проверки для методов After и Equal
    // ...
} 

Готово

GO
fmt.Println("Is", now, "after", currentTime, "? Answer:", now.After(currentTime))
fmt.Println("Is", now, "equal", currentTime, "? Answer:", now.Equal(currentTime)) 

Тип Duration

Для определения интервала времени используют тип Duration, который содержит количество наносекунд. Это переопределение типа int64.

type Duration int64

Чтобы получить нужный интервал, можно воспользоваться следующими методами:

GO
// Sub возвращает интервал: t — u.
func (t Time) Sub(u Time) Duration

// Since возвращает интервал: текущее время — t.
func Since(t Time) Duration

// Until возвращает интервал: t — текущее время.
func Until(t Time) Duration 

Вот простой пример использования Duration — замер времени выполнения функции:

start := time.Now()
anyFunction()
duration := time.Since(start)

Такой подход часто применяют, чтобы собрать метрики по времени выполнения критически важного кода. Например, когда нужно посчитать длительность обращений в базу данных или продолжительность обработки HTTP-запросов.

В пакете time есть несколько предопределённых интервалов:

GO
const (
    Nanosecond  Duration = 1
    Microsecond          = 1000 * Nanosecond
    Millisecond          = 1000 * Microsecond
    Second               = 1000 * Millisecond
    Minute               = 60 * Second
    Hour                 = 60 * Minute
) 

Чтобы сделать код понятным для других разработчиков, лучше использовать предопределённые интервалы вместо числовых значений и определения собственных констант.

Ещё с помощью Duration можно модифицировать дату и время:

GO
// Add добавляет интервал ко времени.
func (t Time) Add(d Duration) Time

// Round округляет время до начала ближайшего указанного интервала.
func (t Time) Round(d Duration) Time

// Truncate округляет время в меньшую сторону до начала
// ближайшего указанного интервала.
func (t Time) Truncate(d Duration) Time 

Покажем на примере:

GO
now := time.Now()
// добавим 20 секунд к текущему времени
fmt.Println(now.Add(20*time.Second))       
// округлим время до часа
fmt.Println(now.Round(time.Hour))          
// округлим время в меньшую сторону до начала трёхминутного интервала
fmt.Println(now.Truncate(3 * time.Minute))  

Программа выведет:

2021-10-17 22:58:34.280577 +0300 MSK m=+1.000122601
2021-10-17 23:00:00 +0300 MSK
2021-10-17 22:57:00 +0300 MSK

Из Duration можно получить количественные интервалы — наносекунды, микросекунды, миллисекунды, секунды, минуты и часы — с помощью одноимённых методов. Стоит учитывать, что секунды, минуты и часы возвращаются в виде числа с плавающей точкой — float64.

При округлении времени интервалы отсчитываются от начала Unix-эпохи — это полночь 1 января 1970 года в UTC. Например, для 24-часовых форматов интервалы будут округляться до полуночи по UTC, а не до полуночи в локальном часовом поясе.

Для примера запустим программу на компьютере с московским часовым поясом:

GO
package main

import (
    "fmt"
    "time"
)

func main() {
    trunc := time.Date(2022, 1, 1, 0, 0, 0, 0, time.Local).Truncate(24 * time.Hour)
    fmt.Println(trunc)
} 

Программа выведет:

TXT

2021-12-31 03:00:00 +0300 MSK

Задание 4/6

Округлите текущее время до начала дня (полуночи), используя метод Truncate().

GO
package main

import (
    "fmt"
    "time"
)

func main() {
    var today time.Time
    // допишите код
    // ...
    fmt.Println(today)
} 

Обратите внимание на время и часовой пояс в выводе.

Готово

GO
func main() {
    var today time.Time
    today = time.Now().Truncate(24 * time.Hour)
    fmt.Println(today)
} 

Тип Location

Тип Location предназначен для хранения информации о часовом поясе. Например, если в логе указано время, нужно учитывать часовой пояс, который использовался при записи в этот лог.

Получить часовой пояс из строки можно функцией LoadLocation():

GO
func LoadLocation(name string) (*Location, error) 

В пакете time есть два предопределённых часовых пояса:

Local — часовой пояс операционной системы;
UTC — часовой пояс UTC.

По умолчанию информация о часовых поясах берётся из файлов операционной системы. В macOS и Linux такая информация, как правило, есть. На Windows чаще всего доступны только зоны time.UTC и time.Local. Но если на компьютере установлен Go, компилятор может брать информацию о часовом поясе из папки golang.

Чтобы на любом компьютере был доступ к информации о временных зонах, нужно импортировать пакет time/tzdata:

import _ "time/tzdata"

Тогда в бинарник добавится информация о временных зонах из текущей версии базы golang (прибавит примерно 0,5 Мб к размеру итогового файла).

Конвертировать время в нужный часовой пояс можно так:

GO
package main

import (
    "fmt"
    "time"
)

func main() {
    layout := "02.01.06 15:04:05 -07 MST"
    now := time.Now()
    fmt.Println(now.Format(layout))
    loc, _ := time.LoadLocation("Europe/Moscow")
    fmt.Println(now.In(loc).Format(layout))
} 

Пример вывода:

TXT

22.11.22 17:18:27 +05 +05
22.11.22 15:18:27 +03 MSK

Здесь конструкция now.In(loc) приводит время к нужному часовому поясу.

Также можно создать свой часовой пояс методом FixedZone():

GO
func FixedZone(name string, offset int) *Location 

В качестве аргумента offset нужно поставить сдвиг в секундах:

GO
now := time.Now()
// 2021-07-14 22:30:27.478879 +0300 MSK

loc := time.FixedZone("My best zone", 30*60)
fmt.Println(now.In(loc))
// 2021-07-14 20:00:27.478879 +0030 My best zone 

В этом примере задан часовой пояс, смещённый на 30 минут относительно UTC.

Разобравшись с типами Time и Location, вы можете создать собственную временную точку. Например, время начала 2023 года в UTC:

GO
newYear := time.Date(2023, time.January, 1, 0, 0, 0, 0, time.UTC) 

А как посчитать количество дней до своего дня рождения?

Саша

Метод Until() возвращает интервал между текущим временем и временем в будущем. Передай ему дату ближайшего дня рождения, а количество часов из полученного интервала раздели на 24.

Так, мне пора начинку для штруделя делать. И духовку разогревать.

Задание 5/6

Разработчик Андрей родился 26 ноября 1993 года. Посчитайте количество дней до его 100-летия — относительно сегодняшнего дня.

GO
package main

import (
    "fmt"
    "time"
)

func main() {
    // допишите код здесь
    // birthday := time.Date(... , time.Local)
    // days := ...
    // fmt.Println(days)
} 

Нужна подсказка

Обратите внимание на функции Date и Until в пакете time.

Готово

GO
package main

import (
    "fmt"
    "time"
)

func main() {
    birthday := time.Date(2093, time.November, 26, 0, 0, 0, 0, time.Local)
    duration := time.Until(birthday)
    days := int(duration.Hours() / 24)
    // альтернативный вариант
    // days := int(duration / time.Hour / 24)
    fmt.Println(days)
} 

Саша

Кстати, ты знаешь, что язык Go родился 10 ноября 2009 года? По случайному совпадению, именно 10 ноября мы запустили наш курс по Go.

Вау!

Саша

Начинка готова — можно заворачивать штрудель и ставить в духовку.

Типы Month и Weekday

Ещё в пакете time есть типы, которые упрощают работу с календарём, — Month и Weekday, переопределения типа int. Они представляют месяц и день недели:

GO
type Month int

const (
    January Month = 1 + iota
    February
    March
    April
    May
    June
    July
    August
    September
    October
    November
    December
)

type Weekday int

const (
    Sunday Weekday = iota
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
) 

Типы Month и Weekday реализуют интерфейс fmt.Stringer, а значит, их можно выводить в человекочитаемом формате.

Остановка программы на время

Иногда нужно приостановить выполнение программы и дождаться определённого момента. Допустим, нужно выводить в консоль Hello, world! каждые две секунды десять раз подряд.

Функция Sleep() приостанавливает выполнение текущей горутины как минимум на интервал, переданный в качестве параметра. Реальное время остановки может быть чуть больше, но в большинстве практических задач этой погрешностью можно пренебречь.

Код будет выглядеть так:

GO
package main

import (
    "fmt"
    "time"
)

func main() {
    for i := 0; i < 10; i++ {
        time.Sleep(2 * time.Second)
        fmt.Println("Hello, world!")
    }
} 

Время и горутины

Go — язык, изначально созданный с расчётом на многопоточность. Вы уже знаете, что в него встроены две абстракции, которые реализуют модель CSP. В Go одновременно работающие подзадачи — это горутины.

В пакете time есть функция AfterFunc(), которая запускает горутину спустя указанный промежуток времени:

GO
func AfterFunc(d Duration, f func()) *Timer 

Приведём пример. Пока главная функция занята работой, функция AfterFunc() позволяет параллельно запустить горутину:

GO
package main

import (
    "fmt"
    "time"
)

func main() {
    time.AfterFunc(1*time.Second, func() {
        fmt.Println("Hi from AfterFunc")
    })
    fmt.Println("Hi")
    // ожидаем 2 секунды, чтобы успела запуститься функция в AfterFunc
    time.Sleep(2 * time.Second)
    fmt.Println("Goodbye")
} 

Типы Timer и Ticker

Пакет time содержит типы Timer и Ticker, которые позволяют реализовать таймеры. Timer срабатывает только один раз, а Ticker будет работать до момента, пока его не закроют.

У обоих типов есть поле C — канал, через который можно получать сигнал по истечении времени. Канал представляет собой «туннель», в который одна горутина может «положить» значение определённого типа, а другая — «взять». В обоих типах канал C позволяет только читать значение типа Time, которое равно времени события.

Переменная типа *Timer создаётся функцией NewTimer() и отправляет время в канал C только один раз через указанный промежуток времени:

NewTimer(d Duration) *Timer — создать таймер;
(t *Timer) Stop() bool — остановить таймер.

Переменная типа *Ticker создаётся функцией NewTicker() и отправляет время в канал C постоянно с указанным интервалом:

NewTicker(d Duration) *Ticker — создать тикер;
(t *Ticker) Stop() — остановить тикер.

Данные из канала можно прочитать так:

// прочитать значение из канала
v := <-ch 
// прочитать, если получаемое значение не важно
<- ch

Операция чтения из канала приостанавливает текущую горутину до тех пор, пока в канале не появится значение.

А вот так может выглядеть код, ожидающий срабатывания таймера:

GO
package main

import (
    "fmt"
    "time"
)

func main() {
    start := time.Now()
    timer := time.NewTimer(2 * time.Second) // создаём таймер
    t := <-timer.C                          // ожидаем срабатывания таймера
    fmt.Println(t.Sub(start).Seconds())     // выводим разницу во времени
} 

Саша

Ох, про таймер-то мы и забыли. Что-то я увлёкся — многозадачность не моя сильная сторона. Штрудель слегка подгорел.

Думаю, он всё равно получился очень вкусный.

Саша

Сейчас проверим! Наливаю чай.

Задание 6/6

Используя Ticker, напишите программу, которая десять раз с интервалом в две секунды выведет разницу в секундах между текущим временем и временем запуска программы. Лучше выводить только целую часть секунд.

GO
package main

import (
    "fmt"
    "time"
)

func main() {
    // допишите код здесь
    // ...
} 

Нужна подсказка

Обратите внимание на пример в разделе «Типы Timer и Ticker». Привести к целому числу можно с помощью int(seconds).

Готово

GO
package main

import (
    "fmt"
    "time"
)

func main() {
    start := time.Now()
    ticker := time.NewTicker(2 * time.Second)
    for i := 0; i < 10; i++ {
        t := <-ticker.C
        fmt.Println(int(t.Sub(start).Seconds()))
    }
} 

Штрудель — просто объеденье...

Саша

Так, я вижу, ты уже совсем клюёшь носом.

Кажется, у меня джетлаг. Ужасно хочется спать.

Саша

Понимаю. Прикорни часок на диване. А потом с Лизой и Гошей созвонимся.

Ага, пойду вздремну.

Вы укрылись тёплым пледом и уже видите сны, как вдруг — голос из темноты.

Саша

Просыпайся. Алису будем обучать?

А, Саш, это ты. Который час?

Саша

У нас семь вечера, у ребят уже больше.

Тогда надо вставать. Создашь созвон на своём ноутбуке?

Саша

Да, конечно.

Обучаем Алису

Гоша

Привет! Как там ваши дела?

Мне приснилась голограмма Алисы...

Лиза

Gолограмма? Это что-то новенькое 😆

Саша

Из-за джетлага и не такое бывает.

Лиза

А, тогда понятно. Мы сегодня как раз хотим сделать навык Алисы чуть более дружелюбным.

Гоша

Научим её начинать первый ответ в новой пользовательской сессии с указания текущего времени. При этом Алиса будет учитывать часовой пояс.

Для этого поправим структуру Request в файле internal/models/models.go.

Добавим строковое поле Timezone, в которое, согласно документации по написанию навыков для Алисы, приходит строковое представление временной зоны пользователя. Также добавим новую вложенную структуру Session — в ней будут храниться данные о сессии пользователя:

GO
// Request описывает запрос пользователя.
// См. https://yandex.ru/dev/dialogs/alice/doc/request.html
type Request struct {
        // тут будет, например, строка "Europe/Moscow" для часового пояса Москвы
        Timezone string          `json:"timezone"` 
        Request  SimpleUtterance `json:"request"`
        Session  Session         `json:"session"`
        Version  string          `json:"version"`
}

type Session struct {
        New bool `json:"new"`
} 

Сейчас в структуре Session нас интересует только флаг New. Он сообщит нам, будет ли сессия новой.

Теперь обработаем новые поля внутри хендлера в файле cmd/skill/main.go:

GO
func webhook(w http.ResponseWriter, r *http.Request) {
    //...

    text := "Для вас нет новых сообщений."

    // первый запрос новой сессии
    if req.Session.New {
        // обрабатываем поле Timezone запроса
        tz, err := time.LoadLocation(req.Timezone)
        if err != nil {
            logger.Log.Debug("cannot parse timezone")
            w.WriteHeader(http.StatusBadRequest)
            return
        }
        
        // получаем текущее время в часовом поясе пользователя
        now := time.Now().In(tz)
        hour, minute, _ := now.Clock()
        
        // формируем текст ответа
        text = fmt.Sprintf("Точное время %d часов, %d минут. %s", hour, minute, text)
    }
    
    // заполняем модель ответа
    resp := models.Response{
      Response: models.ResponsePayload{
        Text: text, // Алиса проговорит новый текст
      },
      Version: "1.0",
    }
  
    w.Header().Set("Content-Type", "application/json")
  
    // сериализуем ответ сервера
    enc := json.NewEncoder(w)
    if err := enc.Encode(resp); err != nil {
      logger.Log.Debug("error encoding response", zap.Error(err))
      return
    }
    logger.Log.Debug("sending HTTP 200 response")
  } 

Осталось исправить автотесты в файле cmd/skill/main_test.go:

GO
package main

import (
  "net/http"
  "net/http/httptest"
  "testing"

  "github.com/go-resty/resty/v2"
  "github.com/stretchr/testify/assert"
)

func TestWebhook(t *testing.T) {
  handler := http.HandlerFunc(webhook)
  srv := httptest.NewServer(handler)
  defer srv.Close()

  testCases := []struct {
    name         string
    method       string
    body         string
    expectedCode int
    expectedBody string
  }{
    {
      name:         "method_get",
      method:       http.MethodGet,
      expectedCode: http.StatusMethodNotAllowed,
      expectedBody: "",
    },
    {
      name:         "method_put",
      method:       http.MethodPut,
      expectedCode: http.StatusMethodNotAllowed,
      expectedBody: "",
    },
    {
      name:         "method_delete",
      method:       http.MethodDelete,
      expectedCode: http.StatusMethodNotAllowed,
      expectedBody: "",
    },
    {
      name:         "method_post_without_body",
      method:       http.MethodPost,
      expectedCode: http.StatusInternalServerError,
      expectedBody: "",
    },
    {
      name:         "method_post_unsupported_type",
      method:       http.MethodPost,
      body:         `{"request": {"type": "idunno", "command": "do something"}, "version": "1.0"}`,
      expectedCode: http.StatusUnprocessableEntity,
      expectedBody: "",
    },
    {
      name:         "method_post_success",
      method:       http.MethodPost,
      body:         `{"request": {"type": "SimpleUtterance", "command": "sudo do something"}, "session": {"new": true}, "version": "1.0"}`,
      expectedCode: http.StatusOK,
      // ответ стал сложнее, поэтому сравниваем его с шаблоном вместо точной строки
      expectedBody: `Точное время .* часов, .* минут. Для вас нет новых сообщений.`,
    },
  }

  for _, tc := range testCases {
    t.Run(tc.method, func(t *testing.T) {
      req := resty.New().R()
      req.Method = tc.method
      req.URL = srv.URL

      if len(tc.body) > 0 {
        req.SetHeader("Content-Type", "application/json")
        req.SetBody(tc.body)
      }

      resp, err := req.Send()
      assert.NoError(t, err, "error making HTTP request")

      assert.Equal(t, tc.expectedCode, resp.StatusCode(), "Response code didn't match expected")
      if tc.expectedBody != "" {
        // сравниваем тело ответа с ожидаемым шаблоном
        assert.Regexp(t, tc.expectedBody, string(resp.Body()))
      }
    })
  }
} 

Лиза

Кажется, нам удалось сделать Алису заботливее!

Гоша

А навык — полезнее: теперь его можно использовать как часы.

Спасибо, ребят! Это было интересно.

Саша

Да, было круто. Теперь, наверное, через пару дней созвонимся. Пока-пока!

Дополнительные материалы

go.dev/time — документация пакета time.

Спринт 3

Пакеты time, context. Отмена операций и управление временем выполнения

Время: даты, интервалы, таймеры

Форматирование даты и времени

Задание 1/6

Парсинг даты и времени

Задание 2/6

Интерфейсы типа Time

Задание 3/6

Тип Duration

Задание 4/6

Тип Location

Задание 5/6

Типы Month и Weekday

Остановка программы на время

Время и горутины

Типы Timer и Ticker

Задание 6/6

Обучаем Алису

Дополнительные материалы

00. Введение и входной тест

00. Начало обучения

01. Спринт 1

02. Спринт 2

03. Спринт 3

04. Спринт 4

06. Спринты 5-6. Выпускной проект

07. Спринт 7

08. Спринт 8

09. Спринт 9

10. Спринт 10

12. Спринты 11-12. Второй выпускной проект