···

       
1
       
1
       
+
       
GOOSE_DRIVER="clickhouse"

     

       
2
       
2
       
+
       
GOOSE_MIGRATION_DIR="./migrations/"

     

       
3
       
3
       
+
       
GOOSE_DBSTRING="clickhouse://default:clickhouse@localhost:9000/default?dial_timeout=10s&compress=true"

     

···

       
1
       
1
       
+
       
init:

     

       
2
       
2
       
+
       
  goose status

     

       
3
       
3
       
+
       


     

       
4
       
4
       
+
       
format:

     

       
5
       
5
       
+
       
  go fmt ./...

     

       
6
       
6
       
+
       
  fd .go . | xargs gofumpt -l -w

     

       
7
       
7
       
+
       
  go mod tidy

     

       
8
       
8
       
+
       


     

       
9
       
9
       
+
       
version:

     

       
10
       
10
       
+
       
  #!/usr/bin/env sh

     

       
11
       
11
       
+
       
  VERSION=$(git describe --tags 2>/dev/null || git rev-parse --short HEAD)

     

       
12
       
12
       
+
       
  echo "$VERSION"

     

       
13
       
13
       
+
       


     

       
14
       
14
       
+
       
build: format

     

       
15
       
15
       
+
       
  #!/usr/bin/env sh

     

       
16
       
16
       
+
       
  VERSION=$(just version)

     

       
17
       
17
       
+
       
  go build -ldflags "-X code.kiri.systems/kiri/alky/pkg/metrics.version=$VERSION" .

     

···

       
1
       
1
       
+
       
services:

     

       
2
       
2
       
+
       
  clickhouse:

     

       
3
       
3
       
+
       
    image: clickhouse/clickhouse-server:latest

     

       
4
       
4
       
+
       
    container_name: clickhouse

     

       
5
       
5
       
+
       
    network_mode: host

     

       
6
       
6
       
+
       
    environment:

     

       
7
       
7
       
+
       
      - CLICKHOUSE_DB=default

     

       
8
       
8
       
+
       
      - CLICKHOUSE_USER=default

     

       
9
       
9
       
+
       
      - CLICKHOUSE_DEFAULT_ACCESS_MANAGEMENT=1

     

       
10
       
10
       
+
       
      - CLICKHOUSE_PASSWORD=clickhouse

     

       
11
       
11
       
+
       
    ports:

     

       
12
       
12
       
+
       
      - "8123:8123"

     

       
13
       
13
       
+
       
      - "9000:9000"

     

       
14
       
14
       
+
       
      - "9009:9009"

     

       
15
       
15
       
+
       
    ulimits:

     

       
16
       
16
       
+
       
      nofile:

     

       
17
       
17
       
+
       
        soft: 262144

     

       
18
       
18
       
+
       
        hard: 262144

     

       
19
       
19
       
+
       
    healthcheck:

     

       
20
       
20
       
+
       
      test: wget --no-verbose --tries=1 --spider http://localhost:8123/ping || exit 1

     

       
21
       
21
       
+
       
      interval: 30s

     

       
22
       
22
       
+
       
      timeout: 5s

     

       
23
       
23
       
+
       
      retries: 3

     

       
24
       
24
       
+
       
      start_period: 30s

     

       
25
       
25
       
+
       
    restart: unless-stopped

     

···

       
33
       
33
       
 
       
# Type: Integer

     

       
34
       
34
       
 
       
expiration_time = 300

     

       
35
       
35
       
 
       


     

       
36
       
36
       
+
       
[metrics]

     

       
37
       
37
       
+
       
# ClickHouse connection string

     

       
38
       
38
       
+
       
dsn = "clickhouse://default:clickhouse@localhost:9000/default"

     

       
39
       
39
       
+
       


     

       
40
       
40
       
+
       
# Number of metricsto buffer before sending to ClickHouse

     

       
41
       
41
       
+
       
batch_size = 1000

     

       
42
       
42
       
+
       


     

       
43
       
43
       
+
       
# How often to flush metrics to ClickHouse

     

       
44
       
44
       
+
       
flush_interval = "10s"

     

       
45
       
45
       
+
       


     

       
46
       
46
       
+
       
# How long to retain metrics data

     

       
47
       
47
       
+
       
# This uses time.ParseDuration semantics

     

       
48
       
48
       
+
       
retention_period = "720h"

     

       
49
       
49
       
+
       


     

       
36
       
50
       
 
       
[advanced]

     

       
37
       
51
       
 
       
# Timeout (in milliseconds) for outgoing queries before being cancelled.

     

       
38
       
52
       
 
       
query_timeout = 100

     

···

       
3
       
3
       
 
       
go 1.22.5

     

       
4
       
4
       
 
       


     

       
5
       
5
       
 
       
require (

     

       
6
       
6
       
-
       
	code.kiri.systems/kiri/magna v0.0.0-20240922043826-2c2a1c508469

     

       
6
       
6
       
+
       
	code.kiri.systems/kiri/magna v0.0.0-20250211050847-abb0522bcd30

     

       
7
       
7
       
 
       
	github.com/BurntSushi/toml v1.4.0

     

       
8
       
8
       
+
       
	github.com/ClickHouse/clickhouse-go/v2 v2.31.0

     

       
9
       
9
       
+
       
)

     

       
10
       
10
       
+
       


     

       
11
       
11
       
+
       
require (

     

       
12
       
12
       
+
       
	github.com/ClickHouse/ch-go v0.64.1 // indirect

     

       
13
       
13
       
+
       
	github.com/andybalholm/brotli v1.1.1 // indirect

     

       
14
       
14
       
+
       
	github.com/go-faster/city v1.0.1 // indirect

     

       
15
       
15
       
+
       
	github.com/go-faster/errors v0.7.1 // indirect

     

       
16
       
16
       
+
       
	github.com/google/uuid v1.6.0 // indirect

     

       
17
       
17
       
+
       
	github.com/klauspost/compress v1.17.11 // indirect

     

       
18
       
18
       
+
       
	github.com/paulmach/orb v0.11.1 // indirect

     

       
19
       
19
       
+
       
	github.com/pierrec/lz4/v4 v4.1.22 // indirect

     

       
20
       
20
       
+
       
	github.com/pkg/errors v0.9.1 // indirect

     

       
21
       
21
       
+
       
	github.com/segmentio/asm v1.2.0 // indirect

     

       
22
       
22
       
+
       
	github.com/shopspring/decimal v1.4.0 // indirect

     

       
23
       
23
       
+
       
	go.opentelemetry.io/otel v1.34.0 // indirect

     

       
24
       
24
       
+
       
	go.opentelemetry.io/otel/trace v1.34.0 // indirect

     

       
25
       
25
       
+
       
	golang.org/x/sys v0.30.0 // indirect

     

       
26
       
26
       
+
       
	gopkg.in/yaml.v3 v3.0.1 // indirect

     

       
8
       
27
       
 
       
)

     

···

       
1
       
1
       
-
       
code.kiri.systems/kiri/magna v0.0.0-20240721214902-8d0a079dbd84 h1:igzBX4k3REg0WZExjGLWW7/wu/X+U6QlbMc8aeO2030=

     

       
2
       
2
       
-
       
code.kiri.systems/kiri/magna v0.0.0-20240721214902-8d0a079dbd84/go.mod h1:gSzCiTKyKlUEjGgl/qTb8rxF0QUVuWOEORAsTXA0qyI=

     

       
3
       
3
       
-
       
code.kiri.systems/kiri/magna v0.0.0-20240922043826-2c2a1c508469 h1:LUvvGcJ7DuW3eo7yblNH2igCJzYsbWJQ08iZEXBWplc=

     

       
4
       
4
       
-
       
code.kiri.systems/kiri/magna v0.0.0-20240922043826-2c2a1c508469/go.mod h1:gSzCiTKyKlUEjGgl/qTb8rxF0QUVuWOEORAsTXA0qyI=

     

       
1
       
1
       
+
       
code.kiri.systems/kiri/magna v0.0.0-20250211050847-abb0522bcd30 h1:ORu6TXli7rdqczAOE3Mi+Xc4IlzcgEpNXjUWeNLoqxg=

     

       
2
       
2
       
+
       
code.kiri.systems/kiri/magna v0.0.0-20250211050847-abb0522bcd30/go.mod h1:gSzCiTKyKlUEjGgl/qTb8rxF0QUVuWOEORAsTXA0qyI=

     

       
5
       
3
       
 
       
github.com/BurntSushi/toml v1.4.0 h1:kuoIxZQy2WRRk1pttg9asf+WVv6tWQuBNVmK8+nqPr0=

     

       
6
       
4
       
 
       
github.com/BurntSushi/toml v1.4.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=

     

       
5
       
5
       
+
       
github.com/ClickHouse/ch-go v0.64.1 h1:FWpP+QU4KchgzpEekuv8YoI/fUc4H2r6Bwc5WwrzvcI=

     

       
6
       
6
       
+
       
github.com/ClickHouse/ch-go v0.64.1/go.mod h1:RBUynvczWwVzhS6Up9lPKlH1mrk4UAmle6uzCiW4Pkc=

     

       
7
       
7
       
+
       
github.com/ClickHouse/clickhouse-go/v2 v2.31.0 h1:9MNHRDYXjFTJizGEJM1DfYAqdra/ohprPoZ+LPiuHXQ=

     

       
8
       
8
       
+
       
github.com/ClickHouse/clickhouse-go/v2 v2.31.0/go.mod h1:V1aZaG0ctMbd8KVi+D4loXi97duWYtHiQHMCgipKJcI=

     

       
9
       
9
       
+
       
github.com/andybalholm/brotli v1.1.1 h1:PR2pgnyFznKEugtsUo0xLdDop5SKXd5Qf5ysW+7XdTA=

     

       
10
       
10
       
+
       
github.com/andybalholm/brotli v1.1.1/go.mod h1:05ib4cKhjx3OQYUY22hTVd34Bc8upXjOLL2rKwwZBoA=

     

       
11
       
11
       
+
       
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=

     

       
7
       
12
       
 
       
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=

     

       
8
       
13
       
 
       
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=

     

       
14
       
14
       
+
       
github.com/go-faster/city v1.0.1 h1:4WAxSZ3V2Ws4QRDrscLEDcibJY8uf41H6AhXDrNDcGw=

     

       
15
       
15
       
+
       
github.com/go-faster/city v1.0.1/go.mod h1:jKcUJId49qdW3L1qKHH/3wPeUstCVpVSXTM6vO3VcTw=

     

       
16
       
16
       
+
       
github.com/go-faster/errors v0.7.1 h1:MkJTnDoEdi9pDabt1dpWf7AA8/BaSYZqibYyhZ20AYg=

     

       
17
       
17
       
+
       
github.com/go-faster/errors v0.7.1/go.mod h1:5ySTjWFiphBs07IKuiL69nxdfd5+fzh1u7FPGZP2quo=

     

       
18
       
18
       
+
       
github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=

     

       
19
       
19
       
+
       
github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=

     

       
20
       
20
       
+
       
github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=

     

       
21
       
21
       
+
       
github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=

     

       
22
       
22
       
+
       
github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=

     

       
23
       
23
       
+
       
github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=

     

       
24
       
24
       
+
       
github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=

     

       
25
       
25
       
+
       
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=

     

       
26
       
26
       
+
       
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=

     

       
27
       
27
       
+
       
github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=

     

       
28
       
28
       
+
       
github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=

     

       
29
       
29
       
+
       
github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=

     

       
30
       
30
       
+
       
github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=

     

       
31
       
31
       
+
       
github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=

     

       
32
       
32
       
+
       
github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=

     

       
33
       
33
       
+
       
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=

     

       
34
       
34
       
+
       
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=

     

       
35
       
35
       
+
       
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=

     

       
36
       
36
       
+
       
github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=

     

       
37
       
37
       
+
       
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=

     

       
38
       
38
       
+
       
github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc=

     

       
39
       
39
       
+
       
github.com/paulmach/orb v0.11.1 h1:3koVegMC4X/WeiXYz9iswopaTwMem53NzTJuTF20JzU=

     

       
40
       
40
       
+
       
github.com/paulmach/orb v0.11.1/go.mod h1:5mULz1xQfs3bmQm63QEJA6lNGujuRafwA5S/EnuLaLU=

     

       
41
       
41
       
+
       
github.com/paulmach/protoscan v0.2.1/go.mod h1:SpcSwydNLrxUGSDvXvO0P7g7AuhJ7lcKfDlhJCDw2gY=

     

       
42
       
42
       
+
       
github.com/pierrec/lz4/v4 v4.1.22 h1:cKFw6uJDK+/gfw5BcDL0JL5aBsAFdsIT18eRtLj7VIU=

     

       
43
       
43
       
+
       
github.com/pierrec/lz4/v4 v4.1.22/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=

     

       
44
       
44
       
+
       
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=

     

       
45
       
45
       
+
       
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=

     

       
9
       
46
       
 
       
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=

     

       
10
       
47
       
 
       
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=

     

       
11
       
11
       
-
       
github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=

     

       
12
       
12
       
-
       
github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=

     

       
48
       
48
       
+
       
github.com/segmentio/asm v1.2.0 h1:9BQrFxC+YOHJlTlHGkTrFWf59nbL3XnCoFLTwDCI7ys=

     

       
49
       
49
       
+
       
github.com/segmentio/asm v1.2.0/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs=

     

       
50
       
50
       
+
       
github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k=

     

       
51
       
51
       
+
       
github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME=

     

       
52
       
52
       
+
       
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=

     

       
53
       
53
       
+
       
github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=

     

       
54
       
54
       
+
       
github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=

     

       
55
       
55
       
+
       
github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=

     

       
56
       
56
       
+
       
github.com/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=

     

       
57
       
57
       
+
       
github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI=

     

       
58
       
58
       
+
       
github.com/xdg-go/scram v1.1.1/go.mod h1:RaEWvsqvNKKvBPvcKeFjrG2cJqOkHTiyTpzz23ni57g=

     

       
59
       
59
       
+
       
github.com/xdg-go/stringprep v1.0.3/go.mod h1:W3f5j4i+9rC0kuIEJL0ky1VpHXQU3ocBgklLGvcBnW8=

     

       
60
       
60
       
+
       
github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=

     

       
61
       
61
       
+
       
github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=

     

       
62
       
62
       
+
       
github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d/go.mod h1:rHwXgn7JulP+udvsHwJoVG1YGAP6VLg4y9I5dyZdqmA=

     

       
63
       
63
       
+
       
github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=

     

       
64
       
64
       
+
       
github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=

     

       
65
       
65
       
+
       
go.mongodb.org/mongo-driver v1.11.4/go.mod h1:PTSz5yu21bkT/wXpkS7WR5f0ddqw5quethTUn9WM+2g=

     

       
66
       
66
       
+
       
go.opentelemetry.io/otel v1.34.0 h1:zRLXxLCgL1WyKsPVrgbSdMN4c0FMkDAskSTQP+0hdUY=

     

       
67
       
67
       
+
       
go.opentelemetry.io/otel v1.34.0/go.mod h1:OWFPOQ+h4G8xpyjgqo4SxJYdDQ/qmRH+wivy7zzx9oI=

     

       
68
       
68
       
+
       
go.opentelemetry.io/otel/trace v1.34.0 h1:+ouXS2V8Rd4hp4580a8q23bg0azF2nI8cqLYnC8mh/k=

     

       
69
       
69
       
+
       
go.opentelemetry.io/otel/trace v1.34.0/go.mod h1:Svm7lSjQD7kG7KJ/MUHPVXSDGz2OX4h0M2jHBhmSfRE=

     

       
70
       
70
       
+
       
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=

     

       
71
       
71
       
+
       
golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=

     

       
72
       
72
       
+
       
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=

     

       
73
       
73
       
+
       
golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=

     

       
74
       
74
       
+
       
golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=

     

       
75
       
75
       
+
       
golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=

     

       
76
       
76
       
+
       
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=

     

       
77
       
77
       
+
       
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=

     

       
78
       
78
       
+
       
golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=

     

       
79
       
79
       
+
       
golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=

     

       
80
       
80
       
+
       
golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=

     

       
81
       
81
       
+
       
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     

       
82
       
82
       
+
       
golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     

       
83
       
83
       
+
       
golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     

       
84
       
84
       
+
       
golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     

       
85
       
85
       
+
       
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=

     

       
86
       
86
       
+
       
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

     

       
87
       
87
       
+
       
golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

     

       
88
       
88
       
+
       
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

     

       
89
       
89
       
+
       
golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

     

       
90
       
90
       
+
       
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

     

       
91
       
91
       
+
       
golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=

     

       
92
       
92
       
+
       
golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=

     

       
93
       
93
       
+
       
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=

     

       
94
       
94
       
+
       
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=

     

       
95
       
95
       
+
       
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=

     

       
96
       
96
       
+
       
golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=

     

       
97
       
97
       
+
       
golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=

     

       
98
       
98
       
+
       
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

     

       
99
       
99
       
+
       
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=

     

       
100
       
100
       
+
       
golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=

     

       
101
       
101
       
+
       
golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=

     

       
102
       
102
       
+
       
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

     

       
103
       
103
       
+
       
golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

     

       
104
       
104
       
+
       
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

     

       
105
       
105
       
+
       
golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

     

       
106
       
106
       
+
       
google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=

     

       
107
       
107
       
+
       
google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=

     

       
108
       
108
       
+
       
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

     

       
109
       
109
       
+
       
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=

     

       
110
       
110
       
+
       
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

     

       
111
       
111
       
+
       
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

     

       
13
       
112
       
 
       
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

     

       
14
       
113
       
 
       
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

     

···

       
9
       
9
       
 
       


     

       
10
       
10
       
 
       
	"code.kiri.systems/kiri/alky/pkg/config"

     

       
11
       
11
       
 
       
	"code.kiri.systems/kiri/alky/pkg/dns"

     

       
12
       
12
       
+
       
	"code.kiri.systems/kiri/alky/pkg/metrics"

     

       
12
       
13
       
 
       
	"code.kiri.systems/kiri/alky/pkg/rootservers"

     

       
13
       
14
       
 
       
)

     

       
14
       
15
       
 
       


     
···

       
26
       
27
       
 
       
		log.Fatal(err)

     

       
27
       
28
       
 
       
	}

     

       
28
       
29
       
 
       


     

       
29
       
29
       
-
       
	rootServers, err := rootservers.DecodeRootHints(cfg.Server.RootHintsFile)

     

       
30
       
30
       
+
       
	logger := setupLogger(&cfg)

     

       
31
       
31
       
+
       


     

       
32
       
32
       
+
       
	metricsClient, err := metrics.NewClickHouseMetrics(&cfg.Metrics, logger)

     

       
30
       
33
       
 
       
	if err != nil {

     

       
31
       
34
       
 
       
		log.Fatal(err)

     

       
32
       
35
       
 
       
	}

     

       
33
       
33
       
-
       


     

       
34
       
34
       
-
       
	var logger *slog.Logger

     

       
35
       
35
       
-
       
	switch cfg.Logging.Output {

     

       
36
       
36
       
-
       
	case "file":

     

       
37
       
37
       
-
       
		f, err := os.OpenFile(cfg.Logging.FilePath, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0o644)

     

       
38
       
38
       
-
       
		if err != nil {

     

       
39
       
39
       
-
       
			log.Fatal(err)

     

       
40
       
40
       
-
       
		}

     

       
36
       
36
       
+
       
	defer metricsClient.Close()

     

       
41
       
37
       
 
       


     

       
42
       
42
       
-
       
		logger = slog.New(slog.NewJSONHandler(f, nil))

     

       
43
       
43
       
-
       
	case "stdout":

     

       
44
       
44
       
-
       
		fallthrough

     

       
45
       
45
       
-
       
	default:

     

       
46
       
46
       
-
       
		logger = slog.New(slog.NewJSONHandler(os.Stdout, nil))

     

       
38
       
38
       
+
       
	rootServers, err := rootservers.DecodeRootHints(cfg.Server.RootHintsFile)

     

       
39
       
39
       
+
       
	if err != nil {

     

       
40
       
40
       
+
       
		log.Fatal(err)

     

       
47
       
41
       
 
       
	}

     

       
48
       
42
       
 
       


     

       
49
       
49
       
-
       
	memCache := dns.NewMemoryCache()

     

       
50
       
50
       
-
       
	var cache dns.Cache = memCache

     

       
43
       
43
       
+
       
	cache := dns.NewMemoryCache(5000, 5*time.Minute)

     

       
51
       
44
       
 
       


     

       
52
       
45
       
 
       
	handler := &dns.QueryHandler{

     

       
53
       
46
       
 
       
		RootServers: rootServers,

     

       
54
       
47
       
 
       
		Timeout:     time.Duration(cfg.Advanced.QueryTimeout) * time.Second,

     

       
55
       
55
       
-
       
		Cache:       &cache,

     

       
48
       
48
       
+
       
		Cache:       cache,

     

       
49
       
49
       
+
       
		Logger:      logger,

     

       
56
       
50
       
 
       
	}

     

       
57
       
51
       
 
       


     

       
58
       
58
       
-
       
	logConfig := &dns.LogConfig{Logger: logger}

     

       
52
       
52
       
+
       
	go monitorCacheMetrics(cache, metricsClient, logger)

     

       
59
       
53
       
 
       


     

       
60
       
54
       
 
       
	rateLimitHandler := dns.RateLimitMiddleware(&dns.RateLimitConfig{

     

       
61
       
55
       
 
       
		Rate:           float64(cfg.Ratelimit.Rate),

     
···

       
63
       
57
       
 
       
		WindowLength:   time.Duration(cfg.Ratelimit.Window) * time.Second,

     

       
64
       
58
       
 
       
		ExpirationTime: time.Duration(cfg.Ratelimit.ExpirationTime) * time.Second,

     

       
65
       
59
       
 
       
	})(handler)

     

       
66
       
66
       
-
       
	loggingHandler := dns.LoggingMiddleware(logConfig)(rateLimitHandler)

     

       
60
       
60
       
+
       


     

       
61
       
61
       
+
       
	metricsHandler := metrics.MetricsMiddleware(metricsClient)(rateLimitHandler)

     

       
62
       
62
       
+
       


     

       
63
       
63
       
+
       
	loggingHandler := dns.LoggingMiddleware(&dns.LogConfig{

     

       
64
       
64
       
+
       
		Logger: logger,

     

       
65
       
65
       
+
       
		Level:  slog.LevelInfo,

     

       
66
       
66
       
+
       
	})(metricsHandler)

     

       
67
       
67
       
 
       


     

       
68
       
68
       
 
       
	s := dns.Server{

     

       
69
       
69
       
 
       
		Address:      cfg.Server.Address,

     
···

       
72
       
72
       
 
       
		UDPSize:      512,

     

       
73
       
73
       
 
       
		ReadTimeout:  2 * time.Second,

     

       
74
       
74
       
 
       
		WriteTimeout: 2 * time.Second,

     

       
75
       
75
       
-
       


     

       
76
       
76
       
-
       
		Logger: logger,

     

       
75
       
75
       
+
       
		Logger:       logger,

     

       
77
       
76
       
 
       
	}

     

       
78
       
77
       
 
       


     

       
79
       
78
       
 
       
	if err := s.ListenAndServe(); err != nil {

     

       
80
       
79
       
 
       
		slog.Error("Failed to start server", "error", err)

     

       
81
       
80
       
 
       
	}

     

       
82
       
81
       
 
       
}

     

       
82
       
82
       
+
       


     

       
83
       
83
       
+
       
func monitorCacheMetrics(cache *dns.MemoryCache, metricsClient *metrics.ClickHouseMetrics, logger *slog.Logger) {

     

       
84
       
84
       
+
       
	ticker := time.NewTicker(1 * time.Minute)

     

       
85
       
85
       
+
       
	defer ticker.Stop()

     

       
86
       
86
       
+
       


     

       
87
       
87
       
+
       
	for range ticker.C {

     

       
88
       
88
       
+
       
		stats := cache.GetStats()

     

       
89
       
89
       
+
       
		metricsClient.RecordCacheStats(stats)

     

       
90
       
90
       
+
       
		logger.Info("Cache metrics recorded to ClickHouse")

     

       
91
       
91
       
+
       
	}

     

       
92
       
92
       
+
       
}

     

       
93
       
93
       
+
       


     

       
94
       
94
       
+
       
func setupLogger(cfg *config.Config) *slog.Logger {

     

       
95
       
95
       
+
       
	var logger *slog.Logger

     

       
96
       
96
       
+
       


     

       
97
       
97
       
+
       
	handlerOpts := &slog.HandlerOptions{

     

       
98
       
98
       
+
       
		Level: slog.LevelDebug,

     

       
99
       
99
       
+
       
	}

     

       
100
       
100
       
+
       


     

       
101
       
101
       
+
       
	switch cfg.Logging.Output {

     

       
102
       
102
       
+
       
	case "file":

     

       
103
       
103
       
+
       
		f, err := os.OpenFile(cfg.Logging.FilePath, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0o644)

     

       
104
       
104
       
+
       
		if err != nil {

     

       
105
       
105
       
+
       
			log.Fatal(err)

     

       
106
       
106
       
+
       
		}

     

       
107
       
107
       
+
       


     

       
108
       
108
       
+
       
		logger = slog.New(slog.NewJSONHandler(f, handlerOpts))

     

       
109
       
109
       
+
       
	default:

     

       
110
       
110
       
+
       
		logger = slog.New(slog.NewJSONHandler(os.Stdout, handlerOpts))

     

       
111
       
111
       
+
       
	}

     

       
112
       
112
       
+
       


     

       
113
       
113
       
+
       
	return logger

     

       
114
       
114
       
+
       
}

     

···

       
1
       
1
       
+
       
-- +goose Up

     

       
2
       
2
       
+
       
CREATE TABLE IF NOT EXISTS alky_dns_queries (

     

       
3
       
3
       
+
       
    timestamp DateTime,

     

       
4
       
4
       
+
       
    instance_id String,

     

       
5
       
5
       
+
       
    query_name String,

     

       
6
       
6
       
+
       
    query_type String,

     

       
7
       
7
       
+
       
    query_class String,

     

       
8
       
8
       
+
       
    remote_addr String,

     

       
9
       
9
       
+
       
    response_code String,

     

       
10
       
10
       
+
       
    duration Int64,

     

       
11
       
11
       
+
       
    cache_hit Bool

     

       
12
       
12
       
+
       
) ENGINE = MergeTree()

     

       
13
       
13
       
+
       
PARTITION BY toYYYYMM(timestamp)

     

       
14
       
14
       
+
       
ORDER BY (timestamp, instance_id, query_name)

     

       
15
       
15
       
+
       
TTL timestamp + toIntervalDay(30);

     

       
16
       
16
       
+
       


     

       
17
       
17
       
+
       
CREATE TABLE IF NOT EXISTS alky_dns_cache_metrics (

     

       
18
       
18
       
+
       
    timestamp DateTime,

     

       
19
       
19
       
+
       
    instance_id String,

     

       
20
       
20
       
+
       
    total_queries Int64,

     

       
21
       
21
       
+
       
    cache_hits Int64,

     

       
22
       
22
       
+
       
    cache_misses Int64,

     

       
23
       
23
       
+
       
    negative_hits Int64,

     

       
24
       
24
       
+
       
    positive_hits Int64,

     

       
25
       
25
       
+
       
    evictions    Int64,

     

       
26
       
26
       
+
       
    size         Int,

     

       
27
       
27
       
+
       
) ENGINE = MergeTree()

     

       
28
       
28
       
+
       
PARTITION BY toYYYYMM(timestamp)

     

       
29
       
29
       
+
       
ORDER BY (timestamp, instance_id)

     

       
30
       
30
       
+
       
TTL timestamp + toIntervalDay(30);

     

       
31
       
31
       
+
       


     

       
32
       
32
       
+
       
-- +goose Down

     

       
33
       
33
       
+
       
DROP TABLE IF EXISTS alky_dns_queries;

     

       
34
       
34
       
+
       
DROP TABLE IF EXISTS alky_dns_cache_metrics;

     

···

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
import (

     

       
4
       
4
       
 
       
	"fmt"

     

       
5
       
5
       
+
       
	"time"

     

       
5
       
6
       
 
       


     

       
6
       
7
       
 
       
	"github.com/BurntSushi/toml"

     

       
7
       
8
       
 
       
)

     
···

       
24
       
25
       
 
       
	ExpirationTime int `toml:"expiration_time"`

     

       
25
       
26
       
 
       
}

     

       
26
       
27
       
 
       


     

       
28
       
28
       
+
       
type MetricsConfig struct {

     

       
29
       
29
       
+
       
	DSN             string   `toml:"dsn"`

     

       
30
       
30
       
+
       
	BatchSize       int      `toml:"batch_size"`

     

       
31
       
31
       
+
       
	FlushInterval   duration `toml:"flush_interval"`

     

       
32
       
32
       
+
       
	RetentionPeriod duration `toml:"retention_period"`

     

       
33
       
33
       
+
       
}

     

       
34
       
34
       
+
       


     

       
27
       
35
       
 
       
type AdvancedConfig struct {

     

       
28
       
36
       
 
       
	QueryTimeout int `toml:"query_timeout"`

     

       
29
       
37
       
 
       
}

     
···

       
32
       
40
       
 
       
	Server    ServerConfig    `toml:"server"`

     

       
33
       
41
       
 
       
	Logging   LoggingConfig   `toml:"logging"`

     

       
34
       
42
       
 
       
	Ratelimit RatelimitConfig `toml:"ratelimit"`

     

       
43
       
43
       
+
       
	Metrics   MetricsConfig   `toml:"metrics"`

     

       
35
       
44
       
 
       
	Advanced  AdvancedConfig  `toml:"advanced"`

     

       
36
       
45
       
 
       
}

     

       
37
       
46
       
 
       


     

       
47
       
47
       
+
       
type duration struct {

     

       
48
       
48
       
+
       
	time.Duration

     

       
49
       
49
       
+
       
}

     

       
50
       
50
       
+
       


     

       
51
       
51
       
+
       
func (d *duration) UnmarshalText(text []byte) error {

     

       
52
       
52
       
+
       
	var err error

     

       
53
       
53
       
+
       
	d.Duration, err = time.ParseDuration(string(text))

     

       
54
       
54
       
+
       
	return err

     

       
55
       
55
       
+
       
}

     

       
56
       
56
       
+
       


     

       
38
       
57
       
 
       
func LoadConfig(path string) (Config, error) {

     

       
39
       
58
       
 
       
	cfg := Config{}

     

       
40
       
59
       
 
       
	if _, err := toml.DecodeFile(path, &cfg); err != nil {

     
···

       
55
       
74
       
 
       


     

       
56
       
75
       
 
       
	if cfg.Logging.Output == "file" && cfg.Logging.FilePath == "" {

     

       
57
       
76
       
 
       
		return cfg, fmt.Errorf("If `[logging.output]` is `file` then `file_path` must be set.")

     

       
77
       
77
       
+
       
	}

     

       
78
       
78
       
+
       


     

       
79
       
79
       
+
       
	if cfg.Metrics.DSN == "" {

     

       
80
       
80
       
+
       
		cfg.Metrics.DSN = "clickhouse://localhost:9000/default"

     

       
81
       
81
       
+
       
	}

     

       
82
       
82
       
+
       


     

       
83
       
83
       
+
       
	if cfg.Metrics.BatchSize == 0 {

     

       
84
       
84
       
+
       
		cfg.Metrics.BatchSize = 1000

     

       
85
       
85
       
+
       
	}

     

       
86
       
86
       
+
       


     

       
87
       
87
       
+
       
	if cfg.Metrics.FlushInterval.Duration == 0 {

     

       
88
       
88
       
+
       
		cfg.Metrics.FlushInterval.Duration = 10 * time.Second

     

       
89
       
89
       
+
       
	}

     

       
90
       
90
       
+
       


     

       
91
       
91
       
+
       
	if cfg.Metrics.RetentionPeriod.Duration == 0 {

     

       
92
       
92
       
+
       
		cfg.Metrics.RetentionPeriod.Duration = 30 * 24 * time.Hour

     

       
58
       
93
       
 
       
	}

     

       
59
       
94
       
 
       


     

       
60
       
95
       
 
       
	if cfg.Advanced.QueryTimeout == 0 {

     

···

       
1
       
1
       
 
       
package dns

     

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
import (

     

       
4
       
4
       
+
       
	"log"

     

       
5
       
5
       
+
       
	"strings"

     

       
4
       
6
       
 
       
	"sync"

     

       
5
       
7
       
 
       
	"time"

     

       
6
       
8
       
 
       


     

       
7
       
9
       
 
       
	"code.kiri.systems/kiri/magna"

     

       
8
       
10
       
 
       
)

     

       
9
       
11
       
 
       


     

       
12
       
12
       
+
       
type BailiwickRule int

     

       
13
       
13
       
+
       


     

       
14
       
14
       
+
       
const (

     

       
15
       
15
       
+
       
	BailiwickSame BailiwickRule = iota

     

       
16
       
16
       
+
       
	BailiwickChild

     

       
17
       
17
       
+
       
	BailiwickOutside

     

       
18
       
18
       
+
       
)

     

       
19
       
19
       
+
       


     

       
20
       
20
       
+
       
type CacheEntry struct {

     

       
21
       
21
       
+
       
	Answer      []CachedResourceRecord

     

       
22
       
22
       
+
       
	Authority   []CachedResourceRecord

     

       
23
       
23
       
+
       
	Additional  []CachedResourceRecord

     

       
24
       
24
       
+
       
	NegativeTTL time.Duration

     

       
25
       
25
       
+
       
	ExpireAt    time.Time

     

       
26
       
26
       
+
       
	CreateTime  time.Time

     

       
27
       
27
       
+
       
	IsNegative  bool

     

       
28
       
28
       
+
       
	Bailiwick   string

     

       
29
       
29
       
+
       
}

     

       
30
       
30
       
+
       


     

       
10
       
31
       
 
       
type CachedResourceRecord struct {

     

       
11
       
11
       
-
       
	Record   magna.ResourceRecord

     

       
12
       
12
       
-
       
	ExpireAt time.Time

     

       
32
       
32
       
+
       
	Record        magna.ResourceRecord

     

       
33
       
33
       
+
       
	ExpireAt      time.Time

     

       
34
       
34
       
+
       
	BailiwickRule BailiwickRule

     

       
35
       
35
       
+
       
}

     

       
36
       
36
       
+
       


     

       
37
       
37
       
+
       
type MemoryCache struct {

     

       
38
       
38
       
+
       
	entries        map[string]*CacheEntry

     

       
39
       
39
       
+
       
	mu             sync.RWMutex

     

       
40
       
40
       
+
       
	stats          CacheStats

     

       
41
       
41
       
+
       
	maxSize        int

     

       
42
       
42
       
+
       
	cleaupInterval time.Duration

     

       
13
       
43
       
 
       
}

     

       
14
       
44
       
 
       


     

       
15
       
15
       
-
       
type CacheEntry struct {

     

       
16
       
16
       
-
       
	Answer []CachedResourceRecord

     

       
45
       
45
       
+
       
type CacheStats struct {

     

       
46
       
46
       
+
       
	TotalQueries int64

     

       
47
       
47
       
+
       
	CacheHits    int64

     

       
48
       
48
       
+
       
	CacheMisses  int64

     

       
49
       
49
       
+
       
	NegativeHits int64

     

       
50
       
50
       
+
       
	PositiveHits int64

     

       
51
       
51
       
+
       
	Evictions    int64

     

       
52
       
52
       
+
       
	Size         int

     

       
17
       
53
       
 
       
}

     

       
18
       
54
       
 
       


     

       
19
       
55
       
 
       
type Cache interface {

     

       
20
       
56
       
 
       
	Get(key string) (*CacheEntry, bool)

     

       
21
       
57
       
 
       
	Set(key string, entry *CacheEntry)

     

       
22
       
22
       
-
       
}

     

       
23
       
23
       
-
       


     

       
24
       
24
       
-
       
type MemoryCache struct {

     

       
25
       
25
       
-
       
	entries map[string]*CacheEntry

     

       
26
       
26
       
-
       
	mu      sync.RWMutex

     

       
58
       
58
       
+
       
	Clear()

     

       
59
       
59
       
+
       
	GetStats() *CacheStats

     

       
27
       
60
       
 
       
}

     

       
28
       
61
       
 
       


     

       
29
       
29
       
-
       
func NewMemoryCache() *MemoryCache {

     

       
30
       
30
       
-
       
	return &MemoryCache{

     

       
31
       
31
       
-
       
		entries: make(map[string]*CacheEntry),

     

       
62
       
62
       
+
       
func NewMemoryCache(maxSize int, cleanupInterval time.Duration) *MemoryCache {

     

       
63
       
63
       
+
       
	cache := &MemoryCache{

     

       
64
       
64
       
+
       
		entries:        make(map[string]*CacheEntry),

     

       
65
       
65
       
+
       
		maxSize:        maxSize,

     

       
66
       
66
       
+
       
		cleaupInterval: cleanupInterval,

     

       
32
       
67
       
 
       
	}

     

       
68
       
68
       
+
       


     

       
69
       
69
       
+
       
	go cache.periodicCleanup()

     

       
70
       
70
       
+
       
	return cache

     

       
33
       
71
       
 
       
}

     

       
34
       
72
       
 
       


     

       
35
       
73
       
 
       
func (c *MemoryCache) Get(key string) (*CacheEntry, bool) {

     

       
36
       
74
       
 
       
	c.mu.RLock()

     

       
37
       
75
       
 
       
	c.mu.RUnlock()

     

       
38
       
76
       
 
       


     

       
77
       
77
       
+
       
	c.stats.TotalQueries++

     

       
78
       
78
       
+
       


     

       
79
       
79
       
+
       
	log.Println("looking for: ", key)

     

       
80
       
80
       
+
       
	for k := range c.entries {

     

       
81
       
81
       
+
       
		log.Printf("\t%s\n", k)

     

       
82
       
82
       
+
       
	}

     

       
83
       
83
       
+
       


     

       
84
       
84
       
+
       
	log.Println(c.entries[key])

     

       
85
       
85
       
+
       


     

       
39
       
86
       
 
       
	entry, exists := c.entries[key]

     

       
40
       
87
       
 
       
	if !exists {

     

       
88
       
88
       
+
       
		log.Println("cache miss")

     

       
89
       
89
       
+
       
		c.stats.CacheMisses++

     

       
41
       
90
       
 
       
		return nil, false

     

       
42
       
91
       
 
       
	}

     

       
92
       
92
       
+
       


     

       
93
       
93
       
+
       
	if time.Now().After(entry.ExpireAt) {

     

       
94
       
94
       
+
       
		c.stats.CacheMisses++

     

       
95
       
95
       
+
       
		log.Println("cache expire")

     

       
96
       
96
       
+
       
		return nil, false

     

       
97
       
97
       
+
       
	}

     

       
98
       
98
       
+
       


     

       
99
       
99
       
+
       
	if entry.IsNegative {

     

       
100
       
100
       
+
       
		c.stats.NegativeHits++

     

       
101
       
101
       
+
       
	} else {

     

       
102
       
102
       
+
       
		c.stats.PositiveHits++

     

       
103
       
103
       
+
       
	}

     

       
104
       
104
       
+
       
	c.stats.CacheHits++

     

       
43
       
105
       
 
       


     

       
44
       
106
       
 
       
	return entry, true

     

       
45
       
107
       
 
       
}

     
···

       
48
       
110
       
 
       
	c.mu.Lock()

     

       
49
       
111
       
 
       
	defer c.mu.Unlock()

     

       
50
       
112
       
 
       


     

       
113
       
113
       
+
       
	if len(c.entries) >= c.maxSize {

     

       
114
       
114
       
+
       
		c.evictOldest()

     

       
115
       
115
       
+
       
	}

     

       
116
       
116
       
+
       


     

       
51
       
117
       
 
       
	c.entries[key] = entry

     

       
118
       
118
       
+
       
	c.stats.Size = len(c.entries)

     

       
119
       
119
       
+
       
}

     

       
120
       
120
       
+
       


     

       
121
       
121
       
+
       
func (c *MemoryCache) Clear() {

     

       
122
       
122
       
+
       
	c.mu.Lock()

     

       
123
       
123
       
+
       
	defer c.mu.Unlock()

     

       
124
       
124
       
+
       


     

       
125
       
125
       
+
       
	c.entries = make(map[string]*CacheEntry)

     

       
126
       
126
       
+
       
	c.stats = CacheStats{}

     

       
127
       
127
       
+
       
}

     

       
128
       
128
       
+
       


     

       
129
       
129
       
+
       
func (c *MemoryCache) GetStats() *CacheStats {

     

       
130
       
130
       
+
       
	c.mu.RLock()

     

       
131
       
131
       
+
       
	defer c.mu.RUnlock()

     

       
132
       
132
       
+
       


     

       
133
       
133
       
+
       
	stats := c.stats

     

       
134
       
134
       
+
       
	return &stats

     

       
135
       
135
       
+
       
}

     

       
136
       
136
       
+
       


     

       
137
       
137
       
+
       
func (c *MemoryCache) evictOldest() {

     

       
138
       
138
       
+
       
	var oldestKey string

     

       
139
       
139
       
+
       
	var oldestTime time.Time

     

       
140
       
140
       
+
       


     

       
141
       
141
       
+
       
	first := true

     

       
142
       
142
       
+
       
	for k, e := range c.entries {

     

       
143
       
143
       
+
       
		if first || e.CreateTime.Before(oldestTime) {

     

       
144
       
144
       
+
       
			oldestKey = k

     

       
145
       
145
       
+
       
			oldestTime = e.CreateTime

     

       
146
       
146
       
+
       
			first = false

     

       
147
       
147
       
+
       
		}

     

       
148
       
148
       
+
       
	}

     

       
149
       
149
       
+
       


     

       
150
       
150
       
+
       
	if oldestKey != "" {

     

       
151
       
151
       
+
       
		delete(c.entries, oldestKey)

     

       
152
       
152
       
+
       
		c.stats.Evictions++

     

       
153
       
153
       
+
       
	}

     

       
154
       
154
       
+
       
}

     

       
155
       
155
       
+
       


     

       
156
       
156
       
+
       
func (c *MemoryCache) periodicCleanup() {

     

       
157
       
157
       
+
       
	ticker := time.NewTicker(c.cleaupInterval)

     

       
158
       
158
       
+
       
	defer ticker.Stop()

     

       
159
       
159
       
+
       


     

       
160
       
160
       
+
       
	for range ticker.C {

     

       
161
       
161
       
+
       
		c.cleanup()

     

       
162
       
162
       
+
       
	}

     

       
163
       
163
       
+
       
}

     

       
164
       
164
       
+
       


     

       
165
       
165
       
+
       
func (c *MemoryCache) cleanup() {

     

       
166
       
166
       
+
       
	c.mu.Lock()

     

       
167
       
167
       
+
       
	defer c.mu.Unlock()

     

       
168
       
168
       
+
       


     

       
169
       
169
       
+
       
	now := time.Now()

     

       
170
       
170
       
+
       
	for k, e := range c.entries {

     

       
171
       
171
       
+
       
		if now.After(e.ExpireAt) {

     

       
172
       
172
       
+
       
			delete(c.entries, k)

     

       
173
       
173
       
+
       
		}

     

       
174
       
174
       
+
       
	}

     

       
175
       
175
       
+
       


     

       
176
       
176
       
+
       
	c.stats.Size = len(c.entries)

     

       
177
       
177
       
+
       
}

     

       
178
       
178
       
+
       


     

       
179
       
179
       
+
       
func getMinTTL(records []magna.ResourceRecord) uint32 {

     

       
180
       
180
       
+
       
	if len(records) == 0 {

     

       
181
       
181
       
+
       
		return 0

     

       
182
       
182
       
+
       
	}

     

       
183
       
183
       
+
       


     

       
184
       
184
       
+
       
	minTTL := records[0].TTL

     

       
185
       
185
       
+
       
	for _, rr := range records[1:] {

     

       
186
       
186
       
+
       
		if rr.TTL < minTTL {

     

       
187
       
187
       
+
       
			minTTL = rr.TTL

     

       
188
       
188
       
+
       
		}

     

       
189
       
189
       
+
       
	}

     

       
190
       
190
       
+
       
	return minTTL

     

       
191
       
191
       
+
       
}

     

       
192
       
192
       
+
       


     

       
193
       
193
       
+
       
func CreateCacheEntry(msg *magna.Message, zone string) *CacheEntry {

     

       
194
       
194
       
+
       
	now := time.Now()

     

       
195
       
195
       
+
       
	entry := &CacheEntry{

     

       
196
       
196
       
+
       
		CreateTime: now,

     

       
197
       
197
       
+
       
		IsNegative: msg.Header.RCode == magna.NXDOMAIN,

     

       
198
       
198
       
+
       
		Bailiwick:  zone,

     

       
199
       
199
       
+
       
	}

     

       
200
       
200
       
+
       


     

       
201
       
201
       
+
       
	if entry.IsNegative {

     

       
202
       
202
       
+
       
		var soaTTL uint32

     

       
203
       
203
       
+
       
		for _, auth := range msg.Authority {

     

       
204
       
204
       
+
       
			if auth.RType == magna.SOAType {

     

       
205
       
205
       
+
       
				soaTTL = auth.TTL

     

       
206
       
206
       
+
       
				break

     

       
207
       
207
       
+
       
			}

     

       
208
       
208
       
+
       
		}

     

       
209
       
209
       
+
       


     

       
210
       
210
       
+
       
		if soaTTL == 0 {

     

       
211
       
211
       
+
       
			soaTTL = 900

     

       
212
       
212
       
+
       
		}

     

       
213
       
213
       
+
       


     

       
214
       
214
       
+
       
		entry.NegativeTTL = time.Duration(soaTTL) * time.Second

     

       
215
       
215
       
+
       
		entry.ExpireAt = now.Add(entry.NegativeTTL)

     

       
216
       
216
       
+
       
		entry.Authority = make([]CachedResourceRecord, len(msg.Authority))

     

       
217
       
217
       
+
       
		for i, rr := range msg.Authority {

     

       
218
       
218
       
+
       
			rule := determineBailiwickRule(zone, rr.Name)

     

       
219
       
219
       
+
       
			entry.Authority[i] = CachedResourceRecord{

     

       
220
       
220
       
+
       
				Record:        rr,

     

       
221
       
221
       
+
       
				ExpireAt:      now.Add(time.Duration(rr.TTL) * time.Second),

     

       
222
       
222
       
+
       
				BailiwickRule: rule,

     

       
223
       
223
       
+
       
			}

     

       
224
       
224
       
+
       
		}

     

       
225
       
225
       
+
       


     

       
226
       
226
       
+
       
		return entry

     

       
227
       
227
       
+
       
	}

     

       
228
       
228
       
+
       


     

       
229
       
229
       
+
       
	minTTL := getMinTTL(msg.Answer)

     

       
230
       
230
       
+
       
	entry.ExpireAt = now.Add(time.Duration(minTTL) * time.Second)

     

       
231
       
231
       
+
       


     

       
232
       
232
       
+
       
	entry.Answer = make([]CachedResourceRecord, len(msg.Answer))

     

       
233
       
233
       
+
       
	for i, rr := range msg.Answer {

     

       
234
       
234
       
+
       
		rule := determineBailiwickRule(zone, rr.Name)

     

       
235
       
235
       
+
       
		entry.Answer[i] = CachedResourceRecord{

     

       
236
       
236
       
+
       
			Record:        rr,

     

       
237
       
237
       
+
       
			ExpireAt:      now.Add(time.Duration(rr.TTL) * time.Second),

     

       
238
       
238
       
+
       
			BailiwickRule: rule,

     

       
239
       
239
       
+
       
		}

     

       
240
       
240
       
+
       
	}

     

       
241
       
241
       
+
       


     

       
242
       
242
       
+
       
	entry.Authority = make([]CachedResourceRecord, len(msg.Authority))

     

       
243
       
243
       
+
       
	for i, rr := range msg.Authority {

     

       
244
       
244
       
+
       
		rule := determineBailiwickRule(zone, rr.Name)

     

       
245
       
245
       
+
       
		entry.Authority[i] = CachedResourceRecord{

     

       
246
       
246
       
+
       
			Record:        rr,

     

       
247
       
247
       
+
       
			ExpireAt:      now.Add(time.Duration(rr.TTL) * time.Second),

     

       
248
       
248
       
+
       
			BailiwickRule: rule,

     

       
249
       
249
       
+
       
		}

     

       
250
       
250
       
+
       
	}

     

       
251
       
251
       
+
       


     

       
252
       
252
       
+
       
	entry.Additional = make([]CachedResourceRecord, len(msg.Additional))

     

       
253
       
253
       
+
       
	for i, rr := range msg.Additional {

     

       
254
       
254
       
+
       
		rule := determineBailiwickRule(zone, rr.Name)

     

       
255
       
255
       
+
       
		entry.Additional[i] = CachedResourceRecord{

     

       
256
       
256
       
+
       
			Record:        rr,

     

       
257
       
257
       
+
       
			ExpireAt:      now.Add(time.Duration(rr.TTL) * time.Second),

     

       
258
       
258
       
+
       
			BailiwickRule: rule,

     

       
259
       
259
       
+
       
		}

     

       
260
       
260
       
+
       
	}

     

       
261
       
261
       
+
       


     

       
262
       
262
       
+
       
	return entry

     

       
263
       
263
       
+
       
}

     

       
264
       
264
       
+
       


     

       
265
       
265
       
+
       
func isSubdomainOf(a, b string) bool {

     

       
266
       
266
       
+
       
	if a == b {

     

       
267
       
267
       
+
       
		return true

     

       
268
       
268
       
+
       
	}

     

       
269
       
269
       
+
       


     

       
270
       
270
       
+
       
	return strings.HasSuffix(b, "."+a)

     

       
271
       
271
       
+
       
}

     

       
272
       
272
       
+
       


     

       
273
       
273
       
+
       
func determineBailiwickRule(zone, name string) BailiwickRule {

     

       
274
       
274
       
+
       
	if zone == name {

     

       
275
       
275
       
+
       
		return BailiwickSame

     

       
276
       
276
       
+
       
	}

     

       
277
       
277
       
+
       


     

       
278
       
278
       
+
       
	if isSubdomainOf(zone, name) {

     

       
279
       
279
       
+
       
		return BailiwickChild

     

       
280
       
280
       
+
       
	}

     

       
281
       
281
       
+
       


     

       
282
       
282
       
+
       
	return BailiwickOutside

     

       
283
       
283
       
+
       
}

     

       
284
       
284
       
+
       


     

       
285
       
285
       
+
       
func extractZone(msg *magna.Message) string {

     

       
286
       
286
       
+
       
	for _, auth := range msg.Authority {

     

       
287
       
287
       
+
       
		if auth.RType == magna.SOAType {

     

       
288
       
288
       
+
       
			return auth.Name

     

       
289
       
289
       
+
       
		}

     

       
290
       
290
       
+
       


     

       
291
       
291
       
+
       
		if auth.RType == magna.NSType {

     

       
292
       
292
       
+
       
			return auth.Name

     

       
293
       
293
       
+
       
		}

     

       
294
       
294
       
+
       
	}

     

       
295
       
295
       
+
       


     

       
296
       
296
       
+
       
	if len(msg.Question) > 0 {

     

       
297
       
297
       
+
       
		return msg.Question[0].QName

     

       
298
       
298
       
+
       
	}

     

       
299
       
299
       
+
       


     

       
300
       
300
       
+
       
	return ""

     

       
52
       
301
       
 
       
}

     

···

       
3
       
3
       
 
       
import (

     

       
4
       
4
       
 
       
	"context"

     

       
5
       
5
       
 
       
	"fmt"

     

       
6
       
6
       
+
       
	"log"

     

       
7
       
7
       
+
       
	"log/slog"

     

       
6
       
8
       
 
       
	"net"

     

       
7
       
7
       
-
       
	"strings"

     

       
8
       
9
       
 
       
	"time"

     

       
9
       
10
       
 
       


     

       
10
       
11
       
 
       
	"code.kiri.systems/kiri/magna"

     
···

       
13
       
14
       
 
       
type QueryHandler struct {

     

       
14
       
15
       
 
       
	RootServers []string

     

       
15
       
16
       
 
       
	Timeout     time.Duration

     

       
16
       
16
       
-
       
	Cache       *Cache

     

       
17
       
17
       
+
       
	Cache       *MemoryCache

     

       
18
       
18
       
+
       
	Logger      *slog.Logger

     

       
17
       
19
       
 
       
}

     

       
18
       
20
       
 
       


     

       
19
       
21
       
 
       
type queryResponse struct {

     
···

       
23
       
25
       
 
       
}

     

       
24
       
26
       
 
       


     

       
25
       
27
       
 
       
func (h *QueryHandler) ServeDNS(w ResponseWriter, r *Request) {

     

       
26
       
26
       
-
       
	msg := h.processQuery(r.Message.Encode())

     

       
27
       
27
       
-
       
	w.WriteMsg(msg)

     

       
28
       
28
       
-
       
}

     

       
29
       
29
       
-
       


     

       
30
       
30
       
-
       
func (h *QueryHandler) processQuery(messageBuffer []byte) *magna.Message {

     

       
31
       
31
       
-
       
	var query magna.Message

     

       
32
       
32
       
-
       
	if err := query.Decode(messageBuffer); err != nil {

     

       
33
       
33
       
-
       
		return nil

     

       
28
       
28
       
+
       
	if len(r.Message.Question) < 1 {

     

       
29
       
29
       
+
       
		h.Logger.Debug("received query with no questions")

     

       
30
       
30
       
+
       
		msg := r.Message.CreateReply(r.Message)

     

       
31
       
31
       
+
       
		msg = msg.SetRCode(magna.FORMERR)

     

       
32
       
32
       
+
       
		w.WriteMsg(msg)

     

       
33
       
33
       
+
       
		return

     

       
34
       
34
       
 
       
	}

     

       
35
       
35
       
 
       


     

       
36
       
36
       
-
       
	msg := new(magna.Message)

     

       
37
       
37
       
-
       
	msg = msg.CreateReply(&query)

     

       
36
       
36
       
+
       
	question := r.Message.Question[0]

     

       
37
       
37
       
+
       
	answers, authority, err := h.resolveQuestion(r.Context, question, h.RootServers)

     

       
38
       
38
       
 
       


     

       
39
       
39
       
-
       
	if len(query.Question) < 1 {

     

       
40
       
40
       
-
       
		return msg.SetRCode(magna.FORMERR)

     

       
41
       
41
       
-
       
	}

     

       
42
       
42
       
-
       


     

       
43
       
43
       
-
       
	question := query.Question[0]

     

       
44
       
44
       
-
       
	msg = msg.AddQuestion(question)

     

       
45
       
45
       
-
       


     

       
46
       
46
       
-
       
	if question.QClass != magna.IN {

     

       
47
       
47
       
-
       
		return msg.SetRCode(magna.NOTIMP)

     

       
48
       
48
       
-
       
	}

     

       
39
       
39
       
+
       
	msg := r.Message.CreateReply(r.Message)

     

       
40
       
40
       
+
       
	msg.Header.RA = true

     

       
49
       
41
       
 
       


     

       
50
       
50
       
-
       
	answer, err := h.resolveWithCache(question)

     

       
51
       
42
       
 
       
	if err != nil {

     

       
52
       
52
       
-
       
		return msg.SetRCode(magna.SERVFAIL)

     

       
43
       
43
       
+
       
		if err.Error() == "nxdomain" {

     

       
44
       
44
       
+
       
			msg = msg.SetRCode(magna.NXDOMAIN)

     

       
45
       
45
       
+
       
			msg.Authority = authority

     

       
46
       
46
       
+
       
			msg.Header.NSCount = uint16(len(authority))

     

       
47
       
47
       
+
       
		} else {

     

       
48
       
48
       
+
       
			msg = msg.SetRCode(magna.SERVFAIL)

     

       
49
       
49
       
+
       
		}

     

       
50
       
50
       
+
       
	} else {

     

       
51
       
51
       
+
       
		msg.Answer = answers

     

       
52
       
52
       
+
       
		msg.Header.ANCount = uint16(len(answers))

     

       
53
       
53
       
+
       
		msg = msg.SetRCode(magna.NOERROR)

     

       
53
       
54
       
 
       
	}

     

       
54
       
55
       
 
       


     

       
55
       
55
       
-
       
	if len(answer) == 0 {

     

       
56
       
56
       
-
       
		return msg.SetRCode(magna.NXDOMAIN)

     

       
57
       
57
       
-
       
	}

     

       
56
       
56
       
+
       
	w.WriteMsg(msg)

     

       
57
       
57
       
+
       
}

     

       
58
       
58
       
 
       


     

       
59
       
59
       
-
       
	msg.Header.ANCount = uint16(len(answer))

     

       
60
       
60
       
-
       
	msg.Answer = answer

     

       
61
       
61
       
-
       
	return msg.SetRCode(magna.NOERROR)

     

       
59
       
59
       
+
       
func (h *QueryHandler) resolveQuestion(ctx context.Context, question magna.Question, servers []string) ([]magna.ResourceRecord, []magna.ResourceRecord, error) {

     

       
60
       
60
       
+
       
	return h.resolveQuestionWithZone(ctx, question, servers, ".")

     

       
62
       
61
       
 
       
}

     

       
63
       
62
       
 
       


     

       
64
       
64
       
-
       
func (h *QueryHandler) resolveWithCache(question magna.Question) ([]magna.ResourceRecord, error) {

     

       
65
       
65
       
-
       
	cacheKey := fmt.Sprintf("%s:%s:%s", strings.ToLower(question.QName), question.QType.String(), question.QClass.String())

     

       
63
       
63
       
+
       
func (h *QueryHandler) resolveQuestionWithZone(ctx context.Context, question magna.Question, servers []string, currentZone string) ([]magna.ResourceRecord, []magna.ResourceRecord, error) {

     

       
64
       
64
       
+
       
	cacheKey := fmt.Sprintf("%s:%s:%s", question.QName, question.QType.String(), question.QClass.String())

     

       
66
       
65
       
 
       


     

       
67
       
67
       
-
       
	if e, found := (*h.Cache).Get(cacheKey); found {

     

       
68
       
68
       
-
       
		now := time.Now()

     

       
69
       
69
       
-
       
		var updatedAnswer []magna.ResourceRecord

     

       
70
       
70
       
-
       
		var cname *magna.ResourceRecord

     

       
71
       
71
       
-
       
		hasAddressRecord := false

     

       
66
       
66
       
+
       
	if h.Cache != nil {

     

       
67
       
67
       
+
       
		log.Println("cache is set")

     

       
68
       
68
       
+
       
		if entry, hit := h.Cache.Get(cacheKey); hit {

     

       
69
       
69
       
+
       
			log.Println("womp womp here here", entry, hit)

     

       
70
       
70
       
+
       
			log.Println("request context: ", getCurrentRequest(ctx))

     

       
71
       
71
       
+
       
			now := time.Now()

     

       
72
       
72
       
 
       


     

       
73
       
73
       
-
       
		for _, cachedRR := range e.Answer {

     

       
74
       
74
       
-
       
			if now.Before(cachedRR.ExpireAt) {

     

       
75
       
75
       
-
       
				updatedRR := cachedRR.Record

     

       
76
       
76
       
-
       
				updatedRR.TTL = uint32(cachedRR.ExpireAt.Sub(now).Seconds())

     

       
77
       
77
       
-
       
				updatedAnswer = append(updatedAnswer, updatedRR)

     

       
73
       
73
       
+
       
			if r := getCurrentRequest(ctx); r != nil {

     

       
74
       
74
       
+
       
				r.Context = setCacheHit(r.Context)

     

       
75
       
75
       
+
       
			}

     

       
78
       
76
       
 
       


     

       
79
       
79
       
-
       
				if updatedRR.RType == magna.CNAMEType && cname == nil {

     

       
80
       
80
       
-
       
					cname = &updatedRR

     

       
81
       
81
       
-
       
				} else if updatedRR.RType == question.QType {

     

       
82
       
82
       
-
       
					hasAddressRecord = true

     

       
83
       
83
       
-
       
				}

     

       
77
       
77
       
+
       
			if entry.IsNegative {

     

       
78
       
78
       
+
       
				return nil, convertCachedToMagna(entry.Authority, now), fmt.Errorf("nxdomain")

     

       
84
       
79
       
 
       
			}

     

       
85
       
85
       
-
       
		}

     

       
86
       
80
       
 
       


     

       
87
       
87
       
-
       
		if len(updatedAnswer) > 0 {

     

       
88
       
88
       
-
       
			// add AAAA types when magna supports those record types

     

       
89
       
89
       
-
       
			if cname != nil && !hasAddressRecord && (question.QType == magna.AType) {

     

       
90
       
90
       
-
       
				cnameTarget := cname.RData.String()

     

       
91
       
91
       
-
       
				aRecords, err := h.resolveWithCache(magna.Question{QName: cnameTarget, QType: question.QType, QClass: question.QClass})

     

       
92
       
92
       
-
       
				if err == nil && len(aRecords) > 0 {

     

       
93
       
93
       
-
       
					updatedAnswer = append(updatedAnswer, aRecords...)

     

       
94
       
94
       
-
       
				}

     

       
81
       
81
       
+
       
			validAnswers := convertCachedToMagna(entry.Answer, now)

     

       
82
       
82
       
+
       
			if len(validAnswers) > 0 {

     

       
83
       
83
       
+
       
				return validAnswers, nil, nil

     

       
84
       
84
       
+
       
			}

     

       
85
       
85
       
+
       
		} else {

     

       
86
       
86
       
+
       
			if r := getCurrentRequest(ctx); r != nil {

     

       
87
       
87
       
+
       
				r.Context = setCacheMiss(r.Context)

     

       
95
       
88
       
 
       
			}

     

       
96
       
96
       
-
       
			return updatedAnswer, nil

     

       
97
       
89
       
 
       
		}

     

       
98
       
90
       
 
       
	}

     

       
99
       
91
       
 
       


     

       
100
       
100
       
-
       
	answer, err := h.resolveQuestion(question, h.RootServers)

     

       
101
       
101
       
-
       
	if err != nil {

     

       
102
       
102
       
-
       
		return nil, err

     

       
103
       
103
       
-
       
	}

     

       
104
       
104
       
-
       


     

       
105
       
105
       
-
       
	now := time.Now()

     

       
106
       
106
       
-
       
	cachedAnswer := make([]CachedResourceRecord, len(answer))

     

       
107
       
107
       
-
       
	for i, rr := range answer {

     

       
108
       
108
       
-
       
		cachedAnswer[i] = CachedResourceRecord{

     

       
109
       
109
       
-
       
			Record:   rr,

     

       
110
       
110
       
-
       
			ExpireAt: now.Add(time.Duration(rr.TTL) * time.Second),

     

       
111
       
111
       
-
       
		}

     

       
112
       
112
       
-
       
	}

     

       
113
       
113
       
-
       


     

       
114
       
114
       
-
       
	entry := &CacheEntry{

     

       
115
       
115
       
-
       
		Answer: cachedAnswer,

     

       
116
       
116
       
-
       
	}

     

       
117
       
117
       
-
       
	(*h.Cache).Set(cacheKey, entry)

     

       
118
       
118
       
-
       


     

       
119
       
119
       
-
       
	if len(answer) > 0 && answer[0].RType == magna.CNAMEType && question.QType == magna.AType {

     

       
120
       
120
       
-
       
		cnameTarget := answer[len(answer)-1].RData.String()

     

       
121
       
121
       
-
       
		addressRecords, err := h.resolveWithCache(magna.Question{QName: cnameTarget, QType: question.QType, QClass: question.QClass})

     

       
122
       
122
       
-
       
		if err == nil && len(addressRecords) > 0 {

     

       
123
       
123
       
-
       
			answer = append(answer, addressRecords...)

     

       
124
       
124
       
-
       
		}

     

       
125
       
125
       
-
       
	}

     

       
126
       
126
       
-
       


     

       
127
       
127
       
-
       
	return answer, nil

     

       
128
       
128
       
-
       
}

     

       
129
       
129
       
-
       


     

       
130
       
130
       
-
       
func (h *QueryHandler) resolveQuestion(question magna.Question, servers []string) ([]magna.ResourceRecord, error) {

     

       
131
       
131
       
-
       
	ctx, cancel := context.WithCancel(context.Background())

     

       
92
       
92
       
+
       
	ctx, cancel := context.WithTimeout(ctx, h.Timeout)

     

       
132
       
93
       
 
       
	defer cancel()

     

       
133
       
94
       
 
       


     

       
134
       
95
       
 
       
	ch := make(chan queryResponse, len(servers))

     

       
135
       
135
       
-
       


     

       
136
       
96
       
 
       
	for _, s := range servers {

     

       
137
       
97
       
 
       
		go queryServer(ctx, question, s, ch, h.Timeout)

     

       
138
       
98
       
 
       
	}

     
···

       
141
       
101
       
 
       
		select {

     

       
142
       
102
       
 
       
		case res := <-ch:

     

       
143
       
103
       
 
       
			if res.Error != nil {

     

       
144
       
144
       
-
       
				break

     

       
104
       
104
       
+
       
				h.Logger.Debug("server query failed",

     

       
105
       
105
       
+
       
					"server", res.Server,

     

       
106
       
106
       
+
       
					"error", res.Error)

     

       
107
       
107
       
+
       
				continue

     

       
145
       
108
       
 
       
			}

     

       
146
       
109
       
 
       


     

       
147
       
110
       
 
       
			msg := res.MSG

     

       
111
       
111
       
+
       
			zone := extractZone(&msg)

     

       
112
       
112
       
+
       
			if zone == "" {

     

       
113
       
113
       
+
       
				zone = currentZone

     

       
114
       
114
       
+
       
			}

     

       
115
       
115
       
+
       


     

       
116
       
116
       
+
       
			if msg.Header.RCode == magna.NXDOMAIN {

     

       
117
       
117
       
+
       
				entry := CreateCacheEntry(&msg, zone)

     

       
118
       
118
       
+
       
				h.Cache.Set(cacheKey, entry)

     

       
119
       
119
       
+
       
				now := time.Now()

     

       
120
       
120
       
+
       
				return nil, convertCachedToMagna(entry.Authority, now), fmt.Errorf("nxdomain")

     

       
121
       
121
       
+
       
			}

     

       
122
       
122
       
+
       


     

       
148
       
123
       
 
       
			if msg.Header.ANCount > 0 {

     

       
149
       
124
       
 
       
				if msg.Answer[0].RType == magna.CNAMEType {

     

       
150
       
150
       
-
       
					cname_answers, err := h.resolveQuestion(magna.Question{QName: msg.Answer[0].RData.String(), QType: question.QType, QClass: question.QClass}, h.RootServers)

     

       
151
       
151
       
-
       
					if err != nil {

     

       
152
       
152
       
-
       
						continue

     

       
125
       
125
       
+
       
					h.Logger.Debug("following CNAME",

     

       
126
       
126
       
+
       
						"cname", msg.Answer[0].RData.String())

     

       
127
       
127
       
+
       


     

       
128
       
128
       
+
       
					entry := CreateCacheEntry(&msg, zone)

     

       
129
       
129
       
+
       
					h.Cache.Set(cacheKey, entry)

     

       
130
       
130
       
+
       


     

       
131
       
131
       
+
       
					answers, auth, err := h.resolveQuestionWithZone(ctx, magna.Question{QName: msg.Answer[0].RData.String(), QType: question.QType, QClass: question.QClass}, h.RootServers, zone)

     

       
132
       
132
       
+
       
					if err == nil {

     

       
133
       
133
       
+
       
						return append(msg.Answer, answers...), auth, nil

     

       
153
       
134
       
 
       
					}

     

       
154
       
154
       
-
       
					msg.Answer = append(msg.Answer, cname_answers...)

     

       
135
       
135
       
+
       


     

       
136
       
136
       
+
       
					return nil, auth, err

     

       
155
       
137
       
 
       
				}

     

       
156
       
138
       
 
       


     

       
157
       
157
       
-
       
				return msg.Answer, nil

     

       
139
       
139
       
+
       
				entry := CreateCacheEntry(&msg, zone)

     

       
140
       
140
       
+
       
				h.Cache.Set(cacheKey, entry)

     

       
141
       
141
       
+
       
				return msg.Answer, nil, nil

     

       
158
       
142
       
 
       
			}

     

       
159
       
143
       
 
       


     

       
160
       
144
       
 
       
			if msg.Header.ARCount > 0 {

     
···

       
165
       
149
       
 
       
					}

     

       
166
       
150
       
 
       
				}

     

       
167
       
151
       
 
       


     

       
168
       
168
       
-
       
				return h.resolveQuestion(question, nextZone)

     

       
152
       
152
       
+
       
				if len(nextZone) > 0 {

     

       
153
       
153
       
+
       
					return h.resolveQuestion(ctx, question, nextZone)

     

       
154
       
154
       
+
       
				}

     

       
169
       
155
       
 
       
			}

     

       
170
       
156
       
 
       


     

       
171
       
157
       
 
       
			if msg.Header.NSCount > 0 {

     

       
172
       
172
       
-
       
				var ns []string

     

       
173
       
173
       
-
       
				for _, a := range msg.Authority {

     

       
174
       
174
       
-
       
					if a.RType == magna.NSType {

     

       
175
       
175
       
-
       
						ans, err := h.resolveQuestion(magna.Question{QName: a.RData.String(), QType: magna.AType, QClass: magna.IN}, h.RootServers)

     

       
176
       
176
       
-
       
						if err != nil {

     

       
177
       
177
       
-
       
							break

     

       
158
       
158
       
+
       
				nsRecords := make(map[string]string)

     

       
159
       
159
       
+
       
				glueRecords := make(map[string]string)

     

       
160
       
160
       
+
       


     

       
161
       
161
       
+
       
				if msg.Header.ARCount > 0 {

     

       
162
       
162
       
+
       
					for _, additional := range msg.Additional {

     

       
163
       
163
       
+
       
						if additional.RType == magna.AType {

     

       
164
       
164
       
+
       
							rule := determineBailiwickRule(zone, additional.Name)

     

       
165
       
165
       
+
       
							if rule != BailiwickOutside {

     

       
166
       
166
       
+
       
								glueRecords[additional.Name] = additional.RData.String()

     

       
167
       
167
       
+
       
							}

     

       
178
       
168
       
 
       
						}

     

       
179
       
179
       
-
       
						for _, x := range ans {

     

       
180
       
180
       
-
       
							ns = append(ns, x.RData.String())

     

       
169
       
169
       
+
       
					}

     

       
170
       
170
       
+
       
				}

     

       
171
       
171
       
+
       


     

       
172
       
172
       
+
       
				var nextServers []string

     

       
173
       
173
       
+
       
				var needResolution []string

     

       
174
       
174
       
+
       


     

       
175
       
175
       
+
       
				for _, auth := range msg.Authority {

     

       
176
       
176
       
+
       
					if auth.RType == magna.NSType {

     

       
177
       
177
       
+
       
						rule := determineBailiwickRule(zone, auth.Name)

     

       
178
       
178
       
+
       
						if rule != BailiwickOutside {

     

       
179
       
179
       
+
       
							nsName := auth.RData.String()

     

       
180
       
180
       
+
       
							nsRecords[nsName] = ""

     

       
181
       
181
       
+
       


     

       
182
       
182
       
+
       
							if ip, exists := glueRecords[nsName]; exists {

     

       
183
       
183
       
+
       
								nextServers = append(nextServers, ip)

     

       
184
       
184
       
+
       
							} else {

     

       
185
       
185
       
+
       
								needResolution = append(needResolution, nsName)

     

       
186
       
186
       
+
       
							}

     

       
181
       
187
       
 
       
						}

     

       
182
       
188
       
 
       
					}

     

       
183
       
189
       
 
       
				}

     

       
184
       
190
       
 
       


     

       
185
       
185
       
-
       
				return h.resolveQuestion(question, ns)

     

       
191
       
191
       
+
       
				if len(nextServers) > 0 {

     

       
192
       
192
       
+
       
					h.Logger.Debug("using glue records for resolution",

     

       
193
       
193
       
+
       
						"servers", nextServers)

     

       
194
       
194
       
+
       
					return h.resolveQuestionWithZone(ctx, question, nextServers, zone)

     

       
195
       
195
       
+
       
				}

     

       
196
       
196
       
+
       


     

       
197
       
197
       
+
       
				for _, ns := range needResolution {

     

       
198
       
198
       
+
       
					answers, _, err := h.resolveQuestionWithZone(

     

       
199
       
199
       
+
       
						ctx,

     

       
200
       
200
       
+
       
						magna.Question{

     

       
201
       
201
       
+
       
							QName:  ns,

     

       
202
       
202
       
+
       
							QType:  magna.AType,

     

       
203
       
203
       
+
       
							QClass: magna.IN,

     

       
204
       
204
       
+
       
						},

     

       
205
       
205
       
+
       
						h.RootServers,

     

       
206
       
206
       
+
       
						zone,

     

       
207
       
207
       
+
       
					)

     

       
208
       
208
       
+
       
					if err == nil {

     

       
209
       
209
       
+
       
						for _, ans := range answers {

     

       
210
       
210
       
+
       
							nextServers = append(nextServers, ans.RData.String())

     

       
211
       
211
       
+
       
						}

     

       
212
       
212
       
+
       
					}

     

       
213
       
213
       
+
       
				}

     

       
214
       
214
       
+
       


     

       
215
       
215
       
+
       
				if len(nextServers) > 0 {

     

       
216
       
216
       
+
       
					return h.resolveQuestionWithZone(ctx, question, nextServers, zone)

     

       
217
       
217
       
+
       
				}

     

       
186
       
218
       
 
       
			}

     

       
187
       
219
       
 
       


     

       
188
       
188
       
-
       
			return []magna.ResourceRecord{}, nil

     

       
189
       
189
       
-
       
		case <-time.After(h.Timeout):

     

       
190
       
190
       
-
       
			cancel()

     

       
220
       
220
       
+
       
		case <-ctx.Done():

     

       
221
       
221
       
+
       
			return nil, nil, ctx.Err()

     

       
191
       
222
       
 
       
		}

     

       
192
       
223
       
 
       
	}

     

       
193
       
224
       
 
       


     

       
194
       
194
       
-
       
	return []magna.ResourceRecord{}, nil

     

       
225
       
225
       
+
       
	return nil, nil, fmt.Errorf("all queries failed")

     

       
195
       
226
       
 
       
}

     

       
196
       
227
       
 
       


     

       
197
       
228
       
 
       
func queryServer(ctx context.Context, question magna.Question, server string, ch chan<- queryResponse, timeout time.Duration) {

     
···

       
238
       
269
       
 
       
		ch <- queryResponse{Server: server, Error: fmt.Errorf("timeout")}

     

       
239
       
270
       
 
       
	}

     

       
240
       
271
       
 
       
}

     

       
272
       
272
       
+
       


     

       
273
       
273
       
+
       
func convertCachedToMagna(cached []CachedResourceRecord, now time.Time) []magna.ResourceRecord {

     

       
274
       
274
       
+
       
	result := make([]magna.ResourceRecord, 0, len(cached))

     

       
275
       
275
       
+
       
	for _, record := range cached {

     

       
276
       
276
       
+
       
		if now.Before(record.ExpireAt) {

     

       
277
       
277
       
+
       
			rr := record.Record

     

       
278
       
278
       
+
       
			rr.TTL = uint32(record.ExpireAt.Sub(now).Seconds())

     

       
279
       
279
       
+
       
			result = append(result, rr)

     

       
280
       
280
       
+
       
		}

     

       
281
       
281
       
+
       
	}

     

       
282
       
282
       
+
       
	return result

     

       
283
       
283
       
+
       
}

     

       
284
       
284
       
+
       


     

       
285
       
285
       
+
       
func getCurrentRequest(ctx context.Context) *Request {

     

       
286
       
286
       
+
       
	log.Println(ctx)

     

       
287
       
287
       
+
       
	if ctx == nil {

     

       
288
       
288
       
+
       
		log.Println(">>>>")

     

       
289
       
289
       
+
       
		return nil

     

       
290
       
290
       
+
       
	}

     

       
291
       
291
       
+
       
	if r, ok := ctx.Value(contextKey("request")).(*Request); ok {

     

       
292
       
292
       
+
       
		log.Println("<<<<")

     

       
293
       
293
       
+
       
		return r

     

       
294
       
294
       
+
       
	}

     

       
295
       
295
       
+
       
	log.Println("====")

     

       
296
       
296
       
+
       
	return nil

     

       
297
       
297
       
+
       
}

     

···

       
1
       
1
       
 
       
package dns

     

       
2
       
2
       
 
       


     

       
3
       
3
       
 
       
import (

     

       
4
       
4
       
+
       
	"context"

     

       
4
       
5
       
 
       
	"encoding/binary"

     

       
5
       
6
       
 
       
	"fmt"

     

       
6
       
7
       
 
       
	"io"

     

       
8
       
8
       
+
       
	"log"

     

       
7
       
9
       
 
       
	"log/slog"

     

       
8
       
10
       
 
       
	"net"

     

       
9
       
11
       
 
       
	"sync"

     
···

       
12
       
14
       
 
       
	"code.kiri.systems/kiri/magna"

     

       
13
       
15
       
 
       
)

     

       
14
       
16
       
 
       


     

       
17
       
17
       
+
       
type contextKey string

     

       
18
       
18
       
+
       


     

       
19
       
19
       
+
       
const (

     

       
20
       
20
       
+
       
	cacheHitKey contextKey = "cache_hit"

     

       
21
       
21
       
+
       
)

     

       
22
       
22
       
+
       


     

       
23
       
23
       
+
       
func setCacheHit(ctx context.Context) context.Context {

     

       
24
       
24
       
+
       
	log.Println("setting to true")

     

       
25
       
25
       
+
       
	return context.WithValue(ctx, cacheHitKey, true)

     

       
26
       
26
       
+
       
}

     

       
27
       
27
       
+
       


     

       
28
       
28
       
+
       
func setCacheMiss(ctx context.Context) context.Context {

     

       
29
       
29
       
+
       
	log.Println("setting to false")

     

       
30
       
30
       
+
       
	return context.WithValue(ctx, cacheHitKey, false)

     

       
31
       
31
       
+
       
}

     

       
32
       
32
       
+
       


     

       
33
       
33
       
+
       
func GetCacheHit(ctx context.Context) bool {

     

       
34
       
34
       
+
       
	v := ctx.Value(cacheHitKey)

     

       
35
       
35
       
+
       
	if v == nil {

     

       
36
       
36
       
+
       
		return false

     

       
37
       
37
       
+
       
	}

     

       
38
       
38
       
+
       


     

       
39
       
39
       
+
       
	return v.(bool)

     

       
40
       
40
       
+
       
}

     

       
41
       
41
       
+
       


     

       
15
       
42
       
 
       
type Handler interface {

     

       
16
       
43
       
 
       
	ServeDNS(ResponseWriter, *Request)

     

       
17
       
44
       
 
       
}

     
···

       
23
       
50
       
 
       
}

     

       
24
       
51
       
 
       


     

       
25
       
52
       
 
       
type Request struct {

     

       
53
       
53
       
+
       
	Context    context.Context

     

       
26
       
54
       
 
       
	RemoteAddr net.Addr

     

       
27
       
55
       
 
       
	Message    *magna.Message

     

       
28
       
56
       
 
       
}

     
···

       
89
       
117
       
 
       
	ReadTimeout  time.Duration

     

       
90
       
118
       
 
       
	WriteTimeout time.Duration

     

       
91
       
119
       
 
       
	Logger       *slog.Logger

     

       
92
       
92
       
-
       
	Cache        Cache

     

       
120
       
120
       
+
       
	Cache        *MemoryCache

     

       
93
       
121
       
 
       
}

     

       
94
       
122
       
 
       


     

       
95
       
123
       
 
       
func (srv *Server) ListenAndServe() error {

     
···

       
184
       
212
       
 
       
	for {

     

       
185
       
213
       
 
       
		conn, err := listener.Accept()

     

       
186
       
214
       
 
       
		if err != nil {

     

       
187
       
187
       
-
       
			srv.Logger.Warn("tcp accept error:", err)

     

       
215
       
215
       
+
       
			srv.Logger.Warn("tcp accept error:", "error", err)

     

       
188
       
216
       
 
       
			continue

     

       
189
       
217
       
 
       
		}

     

       
190
       
218
       
 
       


     
···

       
203
       
231
       
 
       


     

       
204
       
232
       
 
       
	sizeBuffer := make([]byte, 2)

     

       
205
       
233
       
 
       
	if _, err := io.ReadFull(conn, sizeBuffer); err != nil {

     

       
206
       
206
       
-
       
		srv.Logger.Warn("tcp-error", err)

     

       
234
       
234
       
+
       
		srv.Logger.Warn("tcp error occurred", "error", err)

     

       
207
       
235
       
 
       
		return

     

       
208
       
236
       
 
       
	}

     

       
209
       
237
       
 
       


     

       
210
       
238
       
 
       
	size := binary.BigEndian.Uint16(sizeBuffer)

     

       
211
       
239
       
 
       
	data := make([]byte, size)

     

       
212
       
240
       
 
       
	if _, err := io.ReadFull(conn, data); err != nil {

     

       
213
       
213
       
-
       
		srv.Logger.Warn("tcp-error", err)

     

       
241
       
241
       
+
       
		srv.Logger.Warn("tcp error occurred", "error", err)

     

       
214
       
242
       
 
       
		return

     

       
215
       
243
       
 
       
	}

     

       
216
       
244
       
 
       


     
···

       
226
       
254
       
 
       
func (srv *Server) handleQuery(messageBuffer []byte, w ResponseWriter, remoteAddr net.Addr) {

     

       
227
       
255
       
 
       
	var query magna.Message

     

       
228
       
256
       
 
       
	if err := query.Decode(messageBuffer); err != nil {

     

       
229
       
229
       
-
       
		srv.Logger.Warn("decode error", err)

     

       
257
       
257
       
+
       
		srv.Logger.Warn("message decode error", "error", err)

     

       
230
       
258
       
 
       
		return

     

       
231
       
259
       
 
       
	}

     

       
232
       
260
       
 
       


     
···

       
234
       
262
       
 
       
		Message:    &query,

     

       
235
       
263
       
 
       
		RemoteAddr: remoteAddr,

     

       
236
       
264
       
 
       
	}

     

       
265
       
265
       
+
       


     

       
266
       
266
       
+
       
  r.Context = context.WithValue(context.Background(), contextKey("request"), r)

     

       
237
       
267
       
 
       


     

       
238
       
268
       
 
       
	srv.Handler.ServeDNS(w, r)

     

       
239
       
269
       
 
       
}