"
18 |
19 | func SaveLocsSnapshot() error {
20 | now := time.Now()
21 | db := utils.MakePGConnection()
22 |
23 | var locs []struct{ Lon, Lat float64 }
24 | _, err := db.Query(&locs, `
25 | SELECT (location->'longitude')::float AS lon, (location->'latitude')::float AS lat
26 | FROM nodes
27 | WHERE updated_at > NOW() - INTERVAL '12 hours'
28 | AND location IS NOT NULL
29 | ORDER BY id`)
30 | if err != nil {
31 | return merry.Wrap(err)
32 | }
33 |
34 | buf := make([]byte, 24+len(locs)*4)
35 | for i, loc := range locs {
36 | lon := uint16((loc.Lon + 180) / 360 * 0x10000)
37 | lat := uint16((loc.Lat + 90) / 180 * 0x10000)
38 | buf[24+i*4+0] = uint8(lon & 0xFF)
39 | buf[24+i*4+1] = uint8(lon >> 8)
40 | buf[24+i*4+2] = uint8(lat & 0xFF)
41 | buf[24+i*4+3] = uint8(lat >> 8)
42 | }
43 | binary.LittleEndian.PutUint64(buf, ^uint64(0))
44 | binary.LittleEndian.PutUint64(buf[8:], uint64(now.Unix()))
45 | binary.LittleEndian.PutUint64(buf[16:], uint64(len(locs)))
46 |
47 | ex, err := os.Executable()
48 | if err != nil {
49 | return merry.Wrap(err)
50 | }
51 | exPath := filepath.Dir(ex)
52 | locDir := exPath + "/history/locations"
53 | if err := os.MkdirAll(locDir, os.ModePerm); err != nil {
54 | return merry.Wrap(err)
55 | }
56 | fpath := locDir + "/" + now.Format("2006-01-02") + ".bin"
57 | fd, err := os.OpenFile(fpath, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0600)
58 | if err != nil {
59 | return merry.Wrap(err)
60 | }
61 | defer fd.Close()
62 | if _, err := fd.Write(buf); err != nil {
63 | return merry.Wrap(err)
64 | }
65 | return merry.Wrap(fd.Close())
66 | }
67 |
68 | func PrintLocsSnapshot(fpath string) error {
69 | log.Info().Msg("starting")
70 |
71 | if fpath == LastFPathLabel {
72 | ex, err := os.Executable()
73 | if err != nil {
74 | return merry.Wrap(err)
75 | }
76 | exPath := filepath.Dir(ex)
77 | locDir := exPath + "/history/locations"
78 | fnames, err := filepath.Glob(locDir + "/*.bin")
79 | if err != nil {
80 | return merry.Wrap(err)
81 | }
82 | sort.Strings(fnames)
83 | if len(fnames) == 0 {
84 | log.Warn().Msg("no files found in default folder " + locDir)
85 | }
86 | fpath = fnames[len(fnames)-1]
87 | }
88 |
89 | fd, err := os.Open(fpath)
90 | if err != nil {
91 | return merry.Wrap(err)
92 | }
93 | defer fd.Close()
94 |
95 | buf, err := io.ReadAll(fd)
96 | if err != nil {
97 | return merry.Wrap(err)
98 | }
99 | if len(buf) == 0 {
100 | log.Warn().Msg("file is empty")
101 | return nil
102 | }
103 |
104 | pos := 0
105 | chunksCount := 0
106 | for {
107 | b := buf[pos:]
108 | if len(b) == 0 {
109 | break
110 | }
111 | if len(b) < 24 {
112 | log.Warn().Msgf("expected 24 more bytes in file, got %d, exiting", len(b))
113 | break
114 | }
115 |
116 | prefix := binary.LittleEndian.Uint64(b)
117 | pos += 8
118 | if prefix != ^uint64(0) {
119 | log.Warn().Msgf("expected prefix at pos %d, found %X, skipping", pos, prefix)
120 | continue
121 | }
122 |
123 | stamp := time.Unix(int64(binary.LittleEndian.Uint64(b[8:])), 0)
124 | fmt.Printf(" === %s === \n", stamp.Format("2006-01-02 15:04:05 -0700"))
125 | pos += 8
126 |
127 | count := int(binary.LittleEndian.Uint64(b[16:]))
128 | fmt.Printf(" -- x%d -- \n", count)
129 | pos += 8
130 | for i := 0; i < count; i++ {
131 | loni := (int64(b[24+i*4+1]) << 8) + int64(b[24+i*4+0])
132 | lati := (int64(b[24+i*4+3]) << 8) + int64(b[24+i*4+2])
133 | lon := (float64(loni)/0x10000)*360 - 180
134 | lat := (float64(lati)/0x10000)*180 - 90
135 | fmt.Printf("loc: %8.3f %7.3f\n", lon, lat)
136 | }
137 | pos += count * 4
138 | chunksCount++
139 | }
140 |
141 | log.Info().Int("chunks", chunksCount).Msg("done")
142 | return nil
143 | }
144 |
--------------------------------------------------------------------------------
/www/src/utils/time.js:
--------------------------------------------------------------------------------
1 | import { useLayoutEffect, useState } from 'preact/hooks'
2 |
3 | export const DAY_DURATION = 24 * 3600 * 1000
4 |
5 | /** @param {Date|number} date */
6 | export function startOfMonth(date) {
7 | let newDate = new Date(date)
8 | newDate.setUTCHours(0, 0, 0, 0)
9 | newDate.setUTCDate(1)
10 | return newDate
11 | }
12 | /** @param {Date|number} date */
13 | export function endOfMonth(date) {
14 | date = startOfMonth(date)
15 | date.setUTCMonth(date.getUTCMonth() + 1)
16 | date.setUTCDate(date.getUTCDate() - 1)
17 | return date
18 | }
19 |
20 | /** @param {Date} date */
21 | export function toISODateString(date) {
22 | return date.toISOString().substr(0, 10)
23 | }
24 |
25 | /** @param {{startDate:Date, endDate:Date}} date */
26 | export function toISODateStringInterval({ startDate, endDate }) {
27 | return { startDateStr: toISODateString(startDate), endDateStr: toISODateString(endDate) }
28 | }
29 |
30 | /**
31 | * @param {string|null} str
32 | * @param {boolean} [isEnd]
33 | */
34 | function parseHashIntervalDate(str, isEnd) {
35 | if (!str) return null
36 | let m = str.trim().match(/^(\d{4})-(\d\d?)(?:-(\d\d?))?$/)
37 | if (m === null) return null
38 | let [, year, month, date] = m
39 |
40 | // this way Date will be at midnight in UTC
41 | let res = new Date(year + '-' + month.padStart(2, '0') + '-' + (date || '1').padStart(2, '0'))
42 | if (res.toString() === 'Invalid Date') return null
43 |
44 | if (isEnd && date === undefined) {
45 | res = endOfMonth(res)
46 | }
47 | return res
48 | }
49 | /**
50 | * @param {Date} date
51 | * @param {boolean} [isEnd]
52 | */
53 | function formatHashIntervalDate(date, isEnd) {
54 | let canTrimDate =
55 | (!isEnd && date.getTime() === startOfMonth(date).getTime()) ||
56 | (isEnd && date.getTime() === endOfMonth(date).getTime())
57 | let str = date.getFullYear() + '-' + (date.getUTCMonth() + 1)
58 | if (canTrimDate) return str
59 | return str + '-' + date.getUTCDate()
60 | }
61 |
62 | /** @returns {[Date, Date]} */
63 | export function getDefaultHashInterval() {
64 | let now = new Date()
65 | return [startOfMonth(now), endOfMonth(now)]
66 | }
67 |
68 | export function intervalIsDefault() {
69 | let [defStart, defEnd] = getDefaultHashInterval()
70 | let [curStart, curEnd] = getHashInterval()
71 | return defStart.getTime() === curStart.getTime() && defEnd.getTime() === curEnd.getTime()
72 | }
73 |
74 | export function intervalIsMonth() {
75 | let [start, end] = getHashInterval()
76 | return +start === +startOfMonth(start) && +end === +endOfMonth(end)
77 | }
78 |
79 | /** @returns {[Date, Date]} */
80 | export function getHashInterval() {
81 | let hash = location.hash.substr(1)
82 | let params = new URLSearchParams(hash)
83 | let start = parseHashIntervalDate(params.get('start'))
84 | let end = parseHashIntervalDate(params.get('end'), true)
85 |
86 | if (start !== null && end !== null && start.getTime() < end.getTime()) {
87 | return [start, end]
88 | } else {
89 | return getDefaultHashInterval()
90 | }
91 | }
92 |
93 | /**
94 | * @param {Date} startDate
95 | * @param {Date} endDate
96 | */
97 | export function makeUpdatedHashInterval(startDate, endDate) {
98 | let hash = location.hash.substr(1)
99 | let params = new URLSearchParams(hash)
100 | params.set('start', formatHashIntervalDate(startDate))
101 | params.set('end', formatHashIntervalDate(endDate, true))
102 | return '#' + params.toString()
103 | }
104 |
105 | /**
106 | * @param {(startDate:Date, endDate:Date) => void} onChange
107 | */
108 | export function watchHashInterval(onChange) {
109 | function listener() {
110 | let [startDate, endDate] = getHashInterval()
111 | onChange(startDate, endDate)
112 | }
113 | function off() {
114 | removeEventListener('hashchange', listener)
115 | }
116 | addEventListener('hashchange', listener)
117 |
118 | let [startDate, endDate] = getHashInterval()
119 | return { startDate, endDate, off }
120 | }
121 |
122 | export function useHashInterval() {
123 | const [interval, setInterval] = useState(getHashInterval)
124 | useLayoutEffect(() => {
125 | const listener = () => setInterval(getHashInterval())
126 | addEventListener('hashchange', listener)
127 | return () => removeEventListener('hashchange', listener)
128 | }, [])
129 | return interval
130 | }
131 |
--------------------------------------------------------------------------------
/www/src/components/user_nodes.css:
--------------------------------------------------------------------------------
1 | .user-nodes-list-with-form {
2 | position: relative;
3 | margin-bottom: 16px;
4 | }
5 |
6 | .user-nodes-list {
7 | position: relative;
8 | display: inline-block;
9 | width: 100%;
10 | min-height: 32px;
11 | overflow-x: auto;
12 | }
13 |
14 | .user-nodes-list .user-nodes-table thead td {
15 | border-bottom: 2px solid transparent;
16 | white-space: nowrap;
17 | }
18 |
19 | .user-nodes-list .user-nodes-table .neighbors-title-cell-inner {
20 | margin: 0 -15px 0 -5px;
21 | }
22 |
23 | .user-nodes-list .node {
24 | /* border-bottom: 1px solid lightgray; */
25 | margin-bottom: 8px;
26 | }
27 | .user-nodes-list .node td {
28 | padding: 1px 5px;
29 | }
30 |
31 | .user-nodes-list .node .node-id {
32 | position: relative;
33 | white-space: nowrap;
34 | font-weight: bold;
35 | font-family: monospace;
36 | font-size: 16px;
37 | }
38 | .user-nodes-list .node .node-id .full {
39 | position: absolute;
40 | left: 0;
41 | top: 0;
42 | background-color: rgba(255, 255, 255, 0.9);
43 | }
44 | .user-nodes-list .node .node-id:not(:hover) .full {
45 | display: none;
46 | }
47 | .user-nodes-list .node .node-status {
48 | display: inline-block;
49 | width: 10px;
50 | height: 10px;
51 | line-height: 16px;
52 | margin: 0 4px 1px 0;
53 | border-radius: 50%;
54 | box-sizing: border-box;
55 | background-color: darkgray;
56 | transition: transform ease 0.1s;
57 | }
58 | .user-nodes-list .node .node-status:hover {
59 | transform: scale(1.4, 1.4);
60 | }
61 | .user-nodes-list .node.status-ok .node-status {
62 | background-color: limegreen;
63 | }
64 | .user-nodes-list .node.status-warn .node-status {
65 | background-color: yellow;
66 | border: 1px solid lightgray;
67 | }
68 | .user-nodes-list .node.status-error .node-status {
69 | background-color: red;
70 | }
71 | .user-nodes-list .node.loading .node-status {
72 | background-color: transparent;
73 | }
74 | .user-nodes-list .node.loading .node-status::after {
75 | content: '⌛';
76 | }
77 |
78 | .user-nodes-list .node .node-ip {
79 | min-width: 128px;
80 | max-width: 196px;
81 | overflow: hidden;
82 | text-overflow: ellipsis;
83 | white-space: nowrap;
84 | text-align: center;
85 | }
86 |
87 | .user-nodes-list .node .node-neighbors {
88 | text-align: center;
89 | }
90 |
91 | .user-nodes-list .node .node-remove-button {
92 | color: darkred;
93 | font-weight: bold;
94 | opacity: 0.5;
95 | border: none;
96 | background: none;
97 | }
98 | .user-nodes-list .node .node-remove-button:hover {
99 | opacity: 1;
100 | }
101 |
102 | .user-nodes-list .ip-info {
103 | white-space: nowrap;
104 | }
105 | .user-nodes-list .ip-info .help-line {
106 | overflow: hidden;
107 | text-overflow: ellipsis;
108 | }
109 | .user-nodes-list .ip-info:hover .help-line {
110 | overflow: visible;
111 | position: relative;
112 | background-color: rgba(255, 255, 255, 0.9);
113 | padding-right: 2px;
114 | margin-right: -2px;
115 | }
116 | .user-nodes-list .ip-info:not(:hover) .help-line {
117 | text-decoration: none;
118 | max-width: 100%;
119 | }
120 | .user-nodes-list .ip-company-name {
121 | max-width: 256px;
122 | }
123 | .user-nodes-list .ip-company-name.compact {
124 | max-width: 192px;
125 | }
126 | .user-nodes-list .ip-as-descr {
127 | max-width: 192px;
128 | }
129 |
130 | table.ip-info-full {
131 | margin-bottom: 12px;
132 | }
133 | table.ip-info-full th {
134 | text-align: right;
135 | vertical-align: top;
136 | padding-right: 8px;
137 | }
138 |
139 | .node-add-form {
140 | position: absolute;
141 | display: flex;
142 | left: 0;
143 | bottom: -5px;
144 | box-shadow: 0 0 2px lightgray;
145 | background-color: rgba(230, 230, 230, 0.8);
146 | border-radius: 3px;
147 | overflow: hidden;
148 | }
149 |
150 | .node-add-form .buttons-wrap {
151 | display: flex;
152 | align-items: flex-end;
153 | flex-direction: column;
154 | justify-content: space-between;
155 | align-items: stretch;
156 | }
157 |
158 | .node-add-form .nodes-data {
159 | margin: 2px;
160 | width: 75vw;
161 | max-width: 640px;
162 | height: 64px;
163 | }
164 |
165 | .node-add-form.minimized .submit-button {
166 | padding-left: 2px;
167 | padding-right: 2px;
168 | }
169 |
170 | .node-add-form:not(:hover) {
171 | opacity: 0.8;
172 | }
173 | .node-add-form.minimized .submit-button,
174 | .node-add-form.minimized .nodes-data {
175 | display: none;
176 | }
177 |
--------------------------------------------------------------------------------
/core/ip_types.go:
--------------------------------------------------------------------------------
1 | package core
2 |
3 | import (
4 | "encoding/json"
5 | "fmt"
6 | "net/http"
7 | "net/netip"
8 | "strconv"
9 | "strings"
10 | "time"
11 |
12 | "github.com/ansel1/merry"
13 | "github.com/go-pg/pg/v10"
14 | "github.com/rs/zerolog/log"
15 | )
16 |
17 | func UpdateASInfoIfNeed(db *pg.DB, asn int64) (bool, error) {
18 | var t int64
19 | _, err := db.Query(pg.Scan(&t), `
20 | SELECT 1 FROM autonomous_systems
21 | WHERE number = ? AND incolumitas IS NOT NULL AND incolumitas_updated_at > NOW() - INTERVAL '7 days'`,
22 | asn)
23 | if t == 1 {
24 | return false, nil
25 | }
26 | if err != nil {
27 | return false, merry.Wrap(err)
28 | }
29 |
30 | info, err := fetchASInfo(asn)
31 | if err != nil {
32 | return false, merry.Wrap(err)
33 | }
34 |
35 | if len(info.Prefixes) == 0 {
36 | log.Warn().Int64("asn", asn).Msg("empty prefixes list")
37 | }
38 | if err := UpdateASPrefixes(db, asn, "incolumitas", info.Prefixes); err != nil {
39 | return false, merry.Wrap(err)
40 | }
41 |
42 | _, err = db.Exec(`
43 | INSERT INTO autonomous_systems (number, incolumitas, incolumitas_updated_at)
44 | VALUES (?, ?, NOW())
45 | ON CONFLICT (number) DO UPDATE SET
46 | incolumitas = EXCLUDED.incolumitas,
47 | incolumitas_updated_at = EXCLUDED.incolumitas_updated_at`,
48 | asn, info.asInfoToSave)
49 | if err != nil {
50 | return false, merry.Wrap(err)
51 | }
52 | return true, nil
53 | }
54 |
55 | func UpdateASPrefixes[T fmt.Stringer](db *pg.DB, asn int64, source string, prefixes []T) error {
56 | prefixesStr := make([]string, len(prefixes))
57 | for i, pref := range prefixes {
58 | prefixesStr[i] = pref.String()
59 | }
60 |
61 | _, err := db.Exec(`
62 | INSERT INTO autonomous_systems_prefixes (prefix, number, source)
63 | SELECT unnest(?::cidr[]), ?, ?
64 | ON CONFLICT (prefix, number, source) DO UPDATE SET
65 | updated_at = EXCLUDED.updated_at`,
66 | pg.Array(prefixesStr), asn, source)
67 | if err != nil {
68 | return merry.Wrap(err)
69 | }
70 | _, err = db.Exec(`
71 | DELETE FROM autonomous_systems_prefixes WHERE number = ? AND source = ? AND prefix NOT IN (?)`,
72 | asn, source, pg.In(prefixesStr))
73 | if err != nil {
74 | return merry.Wrap(err)
75 | }
76 | return nil
77 | }
78 |
79 | type asInfoToSave struct {
80 | Org string `json:"org"`
81 | Descr string `json:"descr"`
82 | Type string `json:"type"`
83 | Domain string `json:"domain"`
84 | }
85 |
86 | type asInfoPrefix netip.Prefix
87 |
88 | func (n *asInfoPrefix) UnmarshalJSON(data []byte) error {
89 | var str string
90 | if err := json.Unmarshal(data, &str); err != nil {
91 | return merry.Wrap(err)
92 | }
93 |
94 | ipnet, err := netip.ParsePrefix(str)
95 | if err != nil {
96 | return merry.Wrap(err)
97 | }
98 |
99 | *n = asInfoPrefix(ipnet)
100 | return nil
101 | }
102 |
103 | func (n asInfoPrefix) String() string {
104 | return netip.Prefix(n).String()
105 | }
106 |
107 | type asInfoResponse struct {
108 | asInfoToSave
109 | Prefixes []asInfoPrefix `json:"prefixes"`
110 | // Asn int64 `json:"asn,omitempty"`
111 | Error string `json:"error"`
112 | Message string `json:"message"`
113 | }
114 |
115 | var ErrIncolumitasTooManyRequests = merry.New("incolumitas: too many requests")
116 |
117 | func fetchASInfo(asn int64) (asInfoResponse, error) {
118 | // previously was api.incolumitas.com
119 | req, err := http.NewRequest("GET", "https://api.ipapi.is/?q=AS"+strconv.FormatInt(asn, 10), nil)
120 | if err != nil {
121 | return asInfoResponse{}, merry.Wrap(err)
122 | }
123 | httpClient := http.Client{
124 | Timeout: 2 * time.Second,
125 | }
126 | resp, err := httpClient.Do(req)
127 | if err != nil {
128 | return asInfoResponse{}, merry.Wrap(err)
129 | }
130 | defer resp.Body.Close()
131 |
132 | info := asInfoResponse{}
133 | if err := json.NewDecoder(resp.Body).Decode(&info); err != nil {
134 | return asInfoResponse{}, merry.Wrap(err)
135 | }
136 | if info.Error != "" {
137 | var err merry.Error
138 | if strings.Contains(info.Message, "Too many API requests") {
139 | err = ErrIncolumitasTooManyRequests
140 | } else {
141 | err = merry.New("")
142 | }
143 | return asInfoResponse{}, err.Here().WithMessagef("ASN %d: %s: %s", asn, info.Error, info.Message)
144 | }
145 |
146 | log.Debug().Int64("ASN", asn).Str("org", info.Org).Str("type", info.Type).Msg("fetched AS type from ipapi (ex incolumitas.com)")
147 | return info, nil
148 | }
149 |
--------------------------------------------------------------------------------
/www/src/components/check_sanctions.js:
--------------------------------------------------------------------------------
1 | import { useCallback, useState } from 'preact/hooks'
2 | import { apiReqIPsSanctions } from 'src/api'
3 | import { L, lang } from 'src/i18n'
4 | import { html } from 'src/utils/htm'
5 | import { NodeSanctionGeneralDescrPP, NodeSanctionDescr } from 'src/utils/nodes'
6 |
7 | import './check_sanctions.css'
8 | import { resolveAllMixed } from 'src/utils/dns'
9 |
10 | export function CheckSanctions() {
11 | const [isLoading, setIsLoading] = useState(false)
12 | const [requestAddrs, setRequestAddrs] = useState(/**@type {string[]}*/ ([]))
13 | const [resolvedIPs, setResolvedIPs] = useState(/**@type {(string|Error)[]|null}*/ (null))
14 | const [response, setResponse] = useState(
15 | /**@type {import('src/api').IPsSanctionsResponse|Error|null}*/ (null),
16 | )
17 |
18 | const onSubmit = useCallback(e => {
19 | e.preventDefault()
20 |
21 | const addrsStr = (new FormData(e.target).get('ips') + '').trim()
22 | if (addrsStr === '') return
23 | const addrs = addrsStr.split(/[\s,]+/)
24 |
25 | setRequestAddrs(addrs)
26 | setResolvedIPs(null)
27 | setResponse(null)
28 | setIsLoading(true)
29 |
30 | resolveAllMixed(addrs)
31 | .then(ipOrErrs => {
32 | setResolvedIPs(ipOrErrs)
33 | const ips = ipOrErrs.filter(x => typeof x === 'string')
34 | return apiReqIPsSanctions(ips, true, null)
35 | })
36 | .then(res => {
37 | setResponse(res)
38 | })
39 | .catch(err => {
40 | setResponse(err)
41 | })
42 | .finally(() => {
43 | setIsLoading(false)
44 | })
45 | }, [])
46 |
47 | return html`
48 |
59 |
60 | ${response instanceof Error
61 | ? html`${response.message}
`
62 | : html`<${IPsTable} addrs=${requestAddrs} resolvedIPs=${resolvedIPs} resp=${response} />`}
63 | <${NodeSanctionGeneralDescrPP} />`
64 | }
65 |
66 | /** @param {{addrs: string[], resolvedIPs:(string|Error)[]|null, resp: import('src/api').IPsSanctionsResponse|null}} props */
67 | function IPsTable({ addrs, resolvedIPs, resp }) {
68 | if (addrs.length === 0) return null
69 |
70 | let maxSubdivsCount = 0
71 | if (resp)
72 | for (const ip in resp.ips) {
73 | const len = resp.ips[ip].fullInfo?.subdivisions.length
74 | if (len && len > maxSubdivsCount) maxSubdivsCount = len
75 | }
76 |
77 | return html`
78 |
79 | IP
80 | ${L('Reason', 'ru', 'Причина')}
81 | ${L('Registration', 'ru', 'Регистрация')}
82 | ${L('Country', 'ru', 'Страна')}
83 | ${L('Region', 'ru', 'Регион')}
84 | ${L('City', 'ru', 'Город')}
85 |
86 | ${addrs.map((addr, addrI) => {
87 | const ip = resolvedIPs?.[addrI]
88 |
89 | const info = typeof ip === 'string' ? resp?.ips[ip] : null
90 | const sanc = info?.sanction
91 | const full = info?.fullInfo
92 |
93 | return html`
94 |
95 | ${addr}
96 | ${ip === addr
97 | ? null
98 | : ip instanceof Error
99 | ? html`${ip.message}
`
100 | : html`${ip ?? ''}
`}
101 |
102 |
103 |
104 | ${sanc ? html`<${NodeSanctionDescr} sanction=${sanc} />` : null}
105 |
106 |
107 |
108 | <${GeoLabel} item=${full?.registeredCountry} />
109 |
110 | <${GeoLabel} item=${full?.country} />
111 | ${Array(maxSubdivsCount)
112 | .fill(0)
113 | .map(i => html`<${GeoLabel} item=${full?.subdivisions[i]} /> `)}
114 | <${GeoLabel} item=${full?.city} />
115 | `
116 | })}
117 |
`
118 | }
119 |
120 | /** @param {{item: {name:string, geoNameID:number, isoCode?:string}|undefined}} props */
121 | function GeoLabel({ item }) {
122 | if (!item || (item.name === '' && item.geoNameID === 0)) return '—'
123 | return html`${item.name}
124 | ${item.isoCode ?? ''}#${item.geoNameID} `
125 | }
126 |
--------------------------------------------------------------------------------
/www/src/main.css:
--------------------------------------------------------------------------------
1 | .dim,
2 | .dim a {
3 | color: darkgray;
4 | transition: color ease 0.2s;
5 | }
6 | .dim:hover,
7 | .dim:hover a {
8 | color: initial;
9 | }
10 |
11 | .small {
12 | font-size: 85%;
13 | }
14 |
15 | .ok {
16 | background-color: #cfc;
17 | }
18 | .warn,
19 | .warn-no-pad {
20 | background-color: #ff9;
21 | }
22 | .ok,
23 | .warn {
24 | padding: 1px;
25 | border-radius: 2px;
26 | }
27 |
28 | .wide-block {
29 | overflow-x: auto;
30 | }
31 |
32 | table {
33 | border-collapse: collapse;
34 | margin: 4px;
35 | }
36 |
37 | thead {
38 | font-weight: bold;
39 | text-align: center;
40 | }
41 |
42 | table.underlined tr {
43 | border-bottom: 1px solid lightgray;
44 | }
45 |
46 | table.wide-padded th:not(:first-child),
47 | table.wide-padded td:not(:first-child) {
48 | padding: 1px 0 1px 15px;
49 | }
50 |
51 | code,
52 | pre {
53 | background-color: #e7e7e7;
54 | border-radius: 2px;
55 | }
56 | pre {
57 | padding: 4px;
58 | overflow: auto;
59 | }
60 |
61 | p,
62 | .p-like,
63 | h2,
64 | h3 {
65 | margin-left: 8px;
66 | margin-right: 8px;
67 | }
68 | p,
69 | .p-like {
70 | margin-top: 16px;
71 | margin-bottom: 16px;
72 | }
73 |
74 | button.a-like {
75 | background: none;
76 | border: none;
77 | padding: 0;
78 | text-decoration: underline dotted;
79 | font: inherit;
80 | cursor: pointer;
81 | user-select: text;
82 | }
83 |
84 | /* =================== */
85 |
86 | html {
87 | min-height: 100%;
88 | }
89 |
90 | body {
91 | display: flex;
92 | flex-direction: column;
93 | margin: 0;
94 | min-height: 100vh;
95 | align-items: stretch;
96 | }
97 |
98 | .header,
99 | .footer {
100 | width: 100%;
101 | background-color: #eee;
102 | box-shadow: 0 0 8px #ccc;
103 | }
104 |
105 | .header-content {
106 | margin: 0 auto;
107 | display: flex;
108 | justify-content: space-between;
109 | max-width: calc(1280px + 24px);
110 | }
111 |
112 | .header-content > * {
113 | margin: 8px 16px;
114 | }
115 |
116 | .header .logo {
117 | color: inherit;
118 | text-decoration: none;
119 | white-space: nowrap;
120 | }
121 | .header .logo .logo-main {
122 | font-size: 130%;
123 | }
124 | .header .logo .logo-sub {
125 | font-size: 80%;
126 | text-align: center;
127 | color: #444;
128 | }
129 |
130 | .header .lang-switch {
131 | display: flex;
132 | align-items: center;
133 | }
134 | .header .lang-switch select {
135 | border: none;
136 | -webkit-appearance: none;
137 | -moz-appearance: none;
138 | appearance: none;
139 | background: none;
140 | cursor: pointer;
141 | margin-left: 4px;
142 | }
143 | @-moz-document url-prefix() {
144 | /* костыль для ФФшного select'а: он рисует справа и слева от элемента лишние отступы */
145 | .header .lang-switch select {
146 | margin-left: 0;
147 | margin-right: -4px;
148 | }
149 | }
150 | .header .lang-switch select:hover {
151 | text-decoration: underline;
152 | }
153 | @media (max-width: 479px) {
154 | .header {
155 | flex-direction: column;
156 | align-items: center;
157 | }
158 | .header .lang-switch {
159 | position: absolute;
160 | top: 10px;
161 | right: 0;
162 | }
163 | }
164 |
165 | .footer {
166 | margin-top: 64px;
167 | padding: 8px 16px;
168 | box-sizing: border-box;
169 | font-size: 85%;
170 | text-align: center;
171 | }
172 |
173 | .content {
174 | position: relative;
175 | flex-grow: 100;
176 | margin: 8px auto;
177 | max-width: 1280px;
178 | width: 100%;
179 | }
180 |
181 | .chart {
182 | position: relative;
183 | height: 96px;
184 | margin: 0 8px;
185 | }
186 |
187 | .chart .main-canvas {
188 | width: 100%;
189 | height: 100%;
190 | }
191 |
192 | .chart .legend {
193 | position: absolute;
194 | display: flex;
195 | flex-direction: row;
196 | flex-wrap: wrap;
197 | top: 0;
198 | font: 9px sans-serif;
199 | text-shadow: 0 0 4px white;
200 | }
201 | .chart .legend:not(.leftmost) {
202 | left: 36px;
203 | }
204 | .chart .legend .item {
205 | display: flex;
206 | align-items: center;
207 | padding: 0 4px;
208 | background: rgba(255, 255, 255, 0.4);
209 | }
210 | .chart .legend .item .example {
211 | width: 12px;
212 | height: 1.4px;
213 | margin-right: 3px;
214 | }
215 |
216 | .upper-block {
217 | display: flex;
218 | flex-direction: row;
219 | justify-content: space-between;
220 | }
221 | .changelog-wrap {
222 | max-width: 256px;
223 | max-height: 150px;
224 | overflow-x: auto;
225 | font-size: 95%;
226 | box-shadow: inset 0 0 16px #f0f0f0, 0px 0px 3px #f0f0f0;
227 | border-radius: 3px;
228 | }
229 | .changelog-wrap h4 {
230 | margin: 3px;
231 | }
232 | .changelog-wrap p {
233 | margin: 3px 3px 8px 3px;
234 | }
235 | @media (max-width: 639px) {
236 | .upper-block {
237 | flex-direction: column;
238 | }
239 | .changelog-wrap {
240 | max-width: initial;
241 | border-radius: 0;
242 | }
243 | }
244 |
--------------------------------------------------------------------------------
/www/src/components/search_neighbors.js:
--------------------------------------------------------------------------------
1 | import { apiReq, apiReqIPsSanctions } from 'src/api'
2 | import { onError } from 'src/errors'
3 | import { L, lang, pluralize } from 'src/i18n'
4 | import { findMeaningfulOctets, isIPv4, resolveSubnetOrNull } from 'src/utils/dns'
5 | import { bindHandlers, NBSP } from 'src/utils/elems'
6 | import { html } from 'src/utils/htm'
7 | import { NodeSanctionDescr, SubnetNeighborsDescription } from 'src/utils/nodes'
8 | import { PureComponent } from 'src/utils/preact_compat'
9 |
10 | function logLine(msg) {
11 | return '- ' + msg + '\n'
12 | }
13 |
14 | function unexpectedErrText(err) {
15 | return L(`Something went wrong`, 'ru', 'Что-то пошло не так') + ': ' + err
16 | }
17 |
18 | /**
19 | * @class
20 | * @typedef SN_State
21 | * @prop {boolean} isLoading
22 | * @prop {string} logText
23 | * @prop {number|null} count
24 | * @prop {import('src/api').NodeIPSanction|null} sanction
25 | * @extends {PureComponent<{}, SN_State>}
26 | */
27 | export class SearchNeighbors extends PureComponent {
28 | constructor() {
29 | super()
30 | /** @type {SN_State} */
31 | this.state = { isLoading: false, logText: '', count: null, sanction: null }
32 | bindHandlers(this)
33 | }
34 |
35 | addLogLines(...lines) {
36 | this.setState({ logText: this.state.logText + lines.map(logLine).join('') })
37 | }
38 |
39 | resolve(name) {
40 | return resolveSubnetOrNull(name, this.addLogLines.bind(this))
41 | }
42 |
43 | async onSubmit(e) {
44 | e.preventDefault()
45 | const address = (new FormData(e.target).get('address') + '').trim()
46 | if (address === '') return
47 |
48 | this.setState({ isLoading: true, logText: '', count: null, sanction: null })
49 | await Promise.resolve() //костыль, чтоб в this.state попал пустой logText
50 |
51 | let subnet = findMeaningfulOctets(address)
52 | if (subnet === null) {
53 | this.addLogLines(
54 | `${address} ` +
55 | L(`doesn't look like IP, `, 'ru', 'не похоже на IP, ') +
56 | L(`trying to resolve via`, 'ru', 'попытаемся отрезолвить через') +
57 | ' cloudflare-dns.com...',
58 | )
59 | subnet = await this.resolve(address)
60 | }
61 | if (subnet === null) {
62 | this.setState({ isLoading: false })
63 | return
64 | }
65 |
66 | const neiPromise = apiReq('GET', `/api/neighbors/${subnet}.0`)
67 | .then(resp => {
68 | this.setState({ count: resp.count })
69 | })
70 | .catch(err => {
71 | if (err.error === 'WRONG_SUBNET_FORMAT') {
72 | this.addLogLines(L('wrong format', 'ru', 'неправильный формат'))
73 | } else {
74 | onError(err)
75 | this.addLogLines(unexpectedErrText(err))
76 | }
77 | })
78 |
79 | const sancIP = isIPv4(address) ? address : subnet ? `${subnet}.0` : null
80 | const sancPromise =
81 | !!sancIP &&
82 | apiReqIPsSanctions([sancIP], false, null)
83 | .then(resp => {
84 | this.setState({ sanction: resp.ips[sancIP]?.sanction ?? null })
85 | })
86 | .catch(err => {
87 | onError(err)
88 | this.addLogLines(unexpectedErrText(err))
89 | })
90 |
91 | await Promise.allSettled([neiPromise, sancPromise]).finally(() => {
92 | this.setState({ isLoading: false })
93 | })
94 | }
95 |
96 | render({}, /**@type {SN_State}*/ { isLoading, logText, count, sanction }) {
97 | return html`
98 |
99 |
109 |
110 |
111 | ${count === null
112 | ? NBSP
113 | : lang === 'ru'
114 | ? html`В подсети ${pluralize(count, 'нашлась', 'нашлось', 'нашлось')}${' '}
115 | ${L.n(count, 'нода', 'ноды', 'нод')} ${' '}
116 |
117 | ${pluralize(count, 'активная', 'активные', 'активных')} за последние 24 часа
118 | `
119 | : html`${L.n(count, 'node', 'nodes')} ${pluralize(count, 'was', 'were')} found in
120 | the subnet${' '} reachable within the last 24 hours `}
121 |
122 |
123 | ${sanction
124 | ? html`<${NodeSanctionDescr} sanction=${sanction} /> ,${' '}
125 | ${L('possible payout problems', 'ru', 'возможны проблемы с выплатами')},${' '}
126 | ${L('more info', 'ru', 'подробнее')} `
127 | : null}
128 |
129 | ${isLoading ? L('Loading…', 'ru', 'Загрузка…') : null}
130 | ${logText && html`${logText} `}
131 |
31 | ${L('After ', 'ru', 'После ')}
32 | v1.30.2
33 | ${L(' nodes respond with an error like ', 'ru', ' ноды отвечают ошибкой типа ')}
34 | satellite is untrusted
35 | ${lang === 'ru'
36 | ? ' на пинги от недоверенных сателлитов. При получении такой ошибки пинг тоже будет считаться успешным.'
37 | : ' to pings from untrusted satellites. If such an error is received, the ping will also be considered successful.'}
38 |
`
39 | }
40 | export function PingModeDescription() {
41 | return html`
42 |
43 | Dial — ${L(' just try to connect to node', 'ru', ' просто попытаться подключиться к ноде')}
44 | ${' '}(${L('ip:port connection', 'ru', 'коннект на ip:port')} + TLS handshake).
45 |
46 |
47 | Ping —
48 | ${lang === 'ru'
49 | ? ' подключиться и отправить пинг (через сторжевый RPC).'
50 | : ' connect and send ping (via Storj RPC).'}
51 | ${' '}
52 | <${Help} letter="*" contentFunc=${getPingDetails} />
53 |
54 | `
55 | }
56 |
57 | export function SubnetNeighborsDescription() {
58 | return html`
59 |
60 | ${L('Since traffic is ', 'ru', 'Т.к. трафик ')}
61 |
62 | ${lang === 'ru'
63 | ? 'делится между всеми нодами в /24-подсети'
64 | : 'divided between all nodes in /24-subnet'}
65 |
66 | ${lang === 'ru'
67 | ? ', лучше разносить ноды по разным подсетям или хотя бы знать, что рядом кто-то делит трафик.'
68 | : ", it's good to keep nodes on different subnets or at least know if someone is sharing traffic."}
69 |
70 |
71 | ${lang === 'ru'
72 | ? `Некоторые ноды (особенно новые) могут не учитываться. ` +
73 | `Если есть сомнения, лучше проверить свою подсеть вручную (например Nmap'ом).`
74 | : 'Some nodes (especially new ones) may not be found. ' +
75 | 'If in doubt, better check your subnet manually (e.g. with Nmap).'}
76 |
77 | `
78 | }
79 |
80 | /** @param {{sanction: {reason: string, detail: string}}} props */
81 | export function NodeSanctionDescr({ sanction }) {
82 | const reason =
83 | sanction?.reason === 'REGISTRATION_COUNTRY'
84 | ? L('IP registration country', 'ru', `Страна регистрации IP${NBHYP}адреса`)
85 | : sanction?.reason === 'LOCATION_REGION'
86 | ? L('IP location', 'ru', `Местоположение IP${NBHYP}адреса`)
87 | : (sanction?.reason ?? '').toLowerCase().replace(/_/g, ' ')
88 | return html`${reason}: ${sanction?.detail} `
89 | }
90 |
91 | export function NodeSanctionGeneralDescrPP() {
92 | const threadUrl = 'https://forum.storj.io/t/missing-payouts-because-node-is-in-a-sanctioned-country'
93 | const logicUrl =
94 | 'https://forum.storj.io/t/missing-payouts-because-node-is-in-a-sanctioned-country/27400/51'
95 |
96 | return html`
97 | ${lang === 'ru'
98 | ? html`Судя по теме на форуме , ноды с адресами в подсанкционных
99 | странах/регионах не получают оплату .`
100 | : html`According to the forum thread , nodes with addresses in
101 | sanctioned countries/regions do not receive payouts .`}
102 | ${' '}
103 | ${lang === 'ru'
104 | ? html`Хотя полного списка таких адресов нет, в${' '}
105 | одном из сообщений описана проверка на санкционность,
106 | аналогичная используется и здесь.`
107 | : html`Although there is no complete list of such addresses,${' '}
108 | one of the posts describes a sanction check, similar one is
109 | used here.`}
110 |
111 |
112 | ${lang === 'ru'
113 | ? `Полный и актуальный исходный код проверки неизвестен. Если есть сомнения, можно воспользоваться скриптом из первого сообщения ветки или обатиться в поддержку.`
114 | : `Complete and up-to-date source code of the check is unknown. If you have doubts, you can use the script from the thread's first post or contact support.`}
115 |
`
116 | }
117 |
--------------------------------------------------------------------------------
/www/src/components/node_countries_chart.js:
--------------------------------------------------------------------------------
1 | import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'preact/hooks'
2 | import { apiReq } from 'src/api'
3 | import { onError } from 'src/errors'
4 | import {
5 | CanvasExt,
6 | drawLabeledVScaleLeftLine,
7 | drawLineStepped,
8 | drawMonthDays,
9 | getArrayMaxValue,
10 | LegendItem,
11 | RectCenter,
12 | roundRange,
13 | View,
14 | } from 'src/utils/charts'
15 | import { delayedRedraw, useResizeEffect } from 'src/utils/elems'
16 | import { html } from 'src/utils/htm'
17 | import { DAY_DURATION, toISODateString, useHashInterval } from 'src/utils/time'
18 |
19 | import './node_countries_chart.css'
20 | import { lang } from 'src/i18n'
21 |
22 | /** @typedef {{name:string, a3:string, counts:Uint16Array}} CountryItem */
23 |
24 | function c(str, n) {
25 | return str.charCodeAt(n) || 0
26 | }
27 |
28 | /** @param {string} name */
29 | function name2col(name) {
30 | // const h = (3600 + 90 - 7 * c(name, 0) - 3 * c(name, 1) + 11 * c(name, 2)) % 360
31 | // let s = 90 - 50 * ((c(name, 0) / 7) % 1) ** 2
32 | // let l = 55 - 25 * ((c(name, 0) / 11) % 1) ** 2
33 | // l = Math.min(l, 50 - 15 * Math.max(0, Math.sin(((h - 45) / 180) * Math.PI)) ** 2)
34 | // return `hsl(${h} ${s}% ${l}%)`
35 | const sum = c(name, 0) + c(name, 1) + c(name, 2)
36 | const max = Math.max(c(name, 0), c(name, 1), c(name, 2))
37 | let r = (max * 1.0031 * c(name, 0) + sum * c(name, 2) + max * c(name, 1)) % 256 | 0
38 | let g = (max * 1.0072 * c(name, 1) + sum * c(name, 0) + max * c(name, 2)) % 256 | 0
39 | let b = (max * 1.0025 * c(name, 2) + sum * c(name, 1) + max * c(name, 0)) % 256 | 0
40 |
41 | const lum = r * 0.21 + g * 0.72 + b * 0.07
42 | let dLum = 0
43 | if (lum > 150) dLum = -130
44 | if (lum < 120) dLum = 120 - lum * 0.75
45 | if (dLum !== 0) {
46 | r = Math.max(0, r + dLum * 0.21) | 0
47 | g = Math.max(0, g + dLum * 0.72) | 0
48 | b = Math.max(0, b + dLum * 0.07) | 0
49 | }
50 | return `rgb(${r},${g},${b})`
51 | }
52 |
53 | export function NodeCountriesChart() {
54 | const canvasExt = useRef(new CanvasExt()).current
55 | const legendBoxRef = useRef(/**@type {HTMLDivElement|null}*/ (null))
56 | const [startDate, endDate] = useHashInterval()
57 |
58 | const [data, setData] = useState(/**@type {{startStamp:number, countries:CountryItem[]}|null}*/ (null))
59 |
60 | const rect = useRef(new RectCenter({ left: 0, right: 0, top: 31, bottom: 11 })).current
61 | const view = useRef(new View({ startStamp: 0, endStamp: 0, bottomValue: 0, topValue: 1 })).current
62 |
63 | const onRedraw = useCallback(() => {
64 | let { rc } = canvasExt
65 |
66 | if (!canvasExt.created() || rc === null) return
67 | canvasExt.resize()
68 |
69 | if (legendBoxRef.current) rect.top = legendBoxRef.current.getBoundingClientRect().height + 1
70 | rect.update(canvasExt.cssWidth, canvasExt.cssHeight)
71 | view.updateStamps(+startDate, +endDate + DAY_DURATION)
72 |
73 | canvasExt.clear()
74 | rc.save()
75 | rc.scale(canvasExt.pixelRatio, canvasExt.pixelRatio)
76 | rc.lineWidth = 1.2
77 |
78 | if (data !== null) {
79 | const { startStamp: start, countries } = data
80 | const step = 3600 * 1000
81 | for (const country of countries) {
82 | const col = name2col(country.a3)
83 | drawLineStepped(rc, rect, view, country.counts, start, step, col, true, false) //value2yLog
84 | }
85 | }
86 |
87 | const textCol = 'black'
88 | const lineCol = 'rgba(0,0,0,0.08)'
89 | const midVal = (view.bottomValue + view.topValue) / 2
90 | rc.textAlign = 'left'
91 | rc.textBaseline = 'bottom'
92 | drawLabeledVScaleLeftLine(rc, rect, view, view.bottomValue, textCol, null, 0, null)
93 | rc.textBaseline = 'middle'
94 | drawLabeledVScaleLeftLine(rc, rect, view, midVal, textCol, lineCol, 0, null)
95 | rc.textBaseline = 'top'
96 | drawLabeledVScaleLeftLine(rc, rect, view, view.topValue, textCol, lineCol, 0, null)
97 |
98 | drawMonthDays(canvasExt, rect, view, {})
99 |
100 | rc.restore()
101 | }, [startDate, endDate, data])
102 | const requestRedraw = useMemo(() => delayedRedraw(onRedraw), [onRedraw])
103 |
104 | useEffect(() => {
105 | const abortController = new AbortController()
106 | apiReq('GET', `/api/nodes/countries`, {
107 | data: { start_date: toISODateString(startDate), end_date: toISODateString(endDate), lang },
108 | signal: abortController.signal,
109 | })
110 | .then(r => r.arrayBuffer())
111 | .then(arrayBuf => {
112 | const uint32Buf = new Uint32Array(arrayBuf, 0, 2)
113 | const startStamp = uint32Buf[0] * 1000
114 | const countsLength = uint32Buf[1]
115 |
116 | /** @type {CountryItem[]} */
117 | const countries = []
118 |
119 | const textDec = new TextDecoder()
120 | const buf = new Uint8Array(arrayBuf)
121 | let pos = 8
122 | let maxCount = 0
123 | while (pos < buf.length) {
124 | const a3AndNameLen = buf[pos]
125 | const a3AndName = textDec.decode(new Uint8Array(arrayBuf, pos + 1, a3AndNameLen))
126 | const [a3, name] = a3AndName.split('|')
127 | let countsOffset = 1 + a3AndNameLen
128 | if (countsOffset % 2 === 1) countsOffset += 1
129 | pos += countsOffset
130 | const counts = new Uint16Array(arrayBuf, pos, countsLength)
131 | pos += 2 * countsLength
132 | countries.push({ name, a3, counts })
133 | maxCount = Math.max(maxCount, getArrayMaxValue(counts))
134 | }
135 |
136 | countries.sort((a, b) => b.counts[countsLength - 1] - a.counts[countsLength - 1])
137 |
138 | setData({ startStamp, countries })
139 | view.updateLimits(...roundRange(0, maxCount))
140 | })
141 | .catch(onError)
142 | return () => abortController.abort()
143 | }, [startDate, endDate])
144 |
145 | useLayoutEffect(() => {
146 | requestRedraw()
147 | }, [requestRedraw])
148 |
149 | useResizeEffect(requestRedraw, [requestRedraw])
150 |
151 | return html`
152 |
153 |
154 |
155 | ${data !== null &&
156 | data.countries.map(x => html`<${LegendItem} color="${name2col(x.a3)}">${x.name}`)}
157 |
158 |
}
83 | */
84 | export function resolve(name) {
85 | const nameEnc = encodeURIComponent(name)
86 | const headers = { Accept: 'application/dns-json' }
87 | // https://developers.cloudflare.com/1.1.1.1/dns-over-https/json-format
88 | return fetch(`https://cloudflare-dns.com/dns-query?name=${nameEnc}&type=A`, { headers })
89 | .then(r => r.json())
90 | .then(response => {
91 | if (response.Status !== 0) {
92 | const status = RESOLVE_STATUS_NAMES_MAP[response.Status] || 'Unknown Error'
93 | throw new ResolveError(`Can not resolve ${name}: ${status}`, response)
94 | }
95 | let ips = Array.isArray(response.Answer)
96 | ? response.Answer.filter(x => x.type === TYPE_A).map(x => x.data + '')
97 | : []
98 | if (ips.length === 0) throw new ResolveError('No IPv4-addresses in response', response)
99 | if (!ips.every(isIPv4)) throw new Error(`not an IPv4: ${JSON.stringify(ips)} (${name})`)
100 | return ips
101 | })
102 | }
103 |
104 | function catchToLog(onLogLines) {
105 | return err => {
106 | if (err instanceof ResolveError) {
107 | onLogLines(...err.messageLines)
108 | } else {
109 | onLogLines('Something went wrong: ' + err)
110 | onError(err)
111 | }
112 | return null
113 | }
114 | }
115 |
116 | /**
117 | * @param {string} ipOrName
118 | */
119 | export function resolveMixed(ipOrName) {
120 | if (isIPv4(ipOrName)) return Promise.resolve([ipOrName])
121 | return resolve(ipOrName)
122 | }
123 |
124 | /**
125 | * @param {string} name
126 | * @param {(...lines:string[]) => void} onLogLines
127 | * @returns {Promise}
128 | */
129 | export function resolveOneOrNull(name, onLogLines) {
130 | return resolve(name)
131 | .then(ips => {
132 | onLogLines(`resolved to [${ips.join(', ')}], using ${ips[0]}`)
133 | return ips[0]
134 | })
135 | .catch(catchToLog(onLogLines))
136 | }
137 |
138 | /**
139 | * @param {string} name
140 | * @param {(...lines:string[]) => void} onLogLines
141 | * @returns {Promise}
142 | */
143 | export function resolveSubnetOrNull(name, onLogLines) {
144 | return resolve(name)
145 | .then(ips => {
146 | const subnet = findMeaningfulOctets(ips[0])
147 | onLogLines(`resolved to [${ips.join(', ')}], using ${subnet}.0`)
148 | return subnet
149 | })
150 | .catch(catchToLog(onLogLines))
151 | }
152 |
153 | /**
154 | *
155 | * @param {string[]} ipOrAddrs
156 | * @param {(addr:string, ip:string|Error) => unknown} [onIP]
157 | */
158 | export function resolveAllMixed(ipOrAddrs, onIP) {
159 | return Promise.all(
160 | ipOrAddrs.map(ipOrAddr => {
161 | return resolveMixed(ipOrAddr)
162 | .then(ips => {
163 | onIP?.(ipOrAddr, ips[0])
164 | return ips[0]
165 | })
166 | .catch((/**@type {Error}*/ err) => {
167 | onIP?.(ipOrAddr, err)
168 | return err
169 | })
170 | }),
171 | )
172 | }
173 |
174 | /**
175 | * @param {string[]} addresses
176 | */
177 | export function useResolved(addresses) {
178 | // special form so we can change outer object (and get reactivity) without copying inner one each time
179 | const [resolved, setResolved] = useState({
180 | addrs: /**@type {Record|Error>}*/ ({}),
181 | })
182 | const updateResolved = useCallback(
183 | (/**@type {string}*/ addr, /**@type {string|Promise|Error}*/ res) => {
184 | const addrs = resolved.addrs
185 | addrs[addr] = res
186 | setResolved({ addrs })
187 | },
188 | [resolved],
189 | )
190 |
191 | useEffect(() => {
192 | for (const address of addresses) {
193 | if (address in resolved.addrs) continue
194 |
195 | let promise = resolveMixed(address)
196 | .then(ips => updateResolved(address, ips[0]))
197 | .catch(err => updateResolved(address, err))
198 | updateResolved(address, promise)
199 | }
200 | }, [addresses, resolved])
201 |
202 | return resolved
203 | }
204 |
--------------------------------------------------------------------------------
/utils/storjutils/ping_proxy.go:
--------------------------------------------------------------------------------
1 | package storjutils
2 |
3 | import (
4 | "bytes"
5 | "encoding/binary"
6 | "encoding/json"
7 | "math/rand"
8 | "net"
9 | "net/http"
10 | "os"
11 | "slices"
12 | "strconv"
13 | "sync/atomic"
14 | "time"
15 |
16 | "github.com/ansel1/merry"
17 | "github.com/rs/zerolog/log"
18 | "storj.io/common/storj"
19 | )
20 |
21 | type PingResult struct {
22 | PingDurations
23 | Error string `json:"error"`
24 | }
25 |
26 | const PingUDPProxyPacketRepeat = 3
27 |
28 | type PingUDPProxyRequest struct {
29 | RequestID uint32
30 | ID string
31 | Addr string
32 | Mode string
33 | Timeout int64
34 | DialOnly bool
35 | }
36 | type PingUDPProxyResponse struct {
37 | RequestID uint32
38 | PingResult
39 | }
40 |
41 | func StartPingProxy(address, identityDirPath, proxyMode string) error {
42 | endpointPath, ok := os.LookupEnv("PROXY_ENDPOINT_PATH")
43 | if !ok {
44 | return merry.New("PROXY_ENDPOINT_PATH env variable is required")
45 | }
46 |
47 | sat := &SatelliteLocal{}
48 | if err := sat.SetUp("Local", identityDirPath); err != nil {
49 | return merry.Wrap(err)
50 | }
51 |
52 | if proxyMode == "http" {
53 | return StartPingHTTPProxy(address, endpointPath, sat)
54 | } else if proxyMode == "udp" {
55 | return StartPingUDPProxy(address, endpointPath, sat)
56 | } else {
57 | return merry.Errorf("invalid proxy mode: %s", proxyMode)
58 | }
59 | }
60 |
61 | func StartPingHTTPProxy(address, endpointPath string, sat *SatelliteLocal) error {
62 |
63 | http.HandleFunc(endpointPath, func(w http.ResponseWriter, r *http.Request) {
64 | query := r.URL.Query()
65 | nodeAddr := query.Get("addr")
66 |
67 | nodeIDStr := query.Get("id")
68 | nodeID, err := storj.NodeIDFromString(nodeIDStr)
69 | if err != nil {
70 | log.Error().Err(err).Str("raw", nodeIDStr).Msg("HTTP: invalid node ID")
71 | w.WriteHeader(http.StatusBadRequest)
72 | return
73 | }
74 |
75 | modeStr := query.Get("mode")
76 | var mode SatMode
77 | if modeStr == "tcp" {
78 | mode = SatModeTCP
79 | } else if modeStr == "quic" {
80 | mode = SatModeQUIC
81 | } else {
82 | log.Error().Err(err).Str("raw", modeStr).Msg("HTTP: invalid mode")
83 | w.WriteHeader(http.StatusBadRequest)
84 | return
85 | }
86 |
87 | timeoutStr := query.Get("timeout")
88 | timeoutMS, err := strconv.Atoi(timeoutStr)
89 | if err != nil || timeoutMS <= 0 || timeoutMS > 60*1000 {
90 | log.Error().Err(err).Str("raw", timeoutStr).Msg("HTTP: invalid timeout")
91 | w.WriteHeader(http.StatusBadRequest)
92 | return
93 | }
94 |
95 | dialOnly := query.Get("dialOnly") == "1"
96 |
97 | durs, err := sat.PingAndClose(nodeAddr, nodeID, mode, dialOnly, time.Duration(timeoutMS)*time.Millisecond)
98 | var errStr string
99 | if err != nil {
100 | errStr = err.Error()
101 | }
102 | json.NewEncoder(w).Encode(PingResult{PingDurations: durs, Error: errStr})
103 | })
104 |
105 | log.Info().Msg("HTTP: starting server on " + address)
106 | return merry.Wrap(http.ListenAndServe(address, nil))
107 | }
108 |
109 | func StartPingUDPProxy(address, endpointPath string, sat *SatelliteLocal) error {
110 | ipStr, portStr, err := net.SplitHostPort(address)
111 | if err != nil {
112 | return merry.Wrap(err)
113 | }
114 | port, err := strconv.Atoi(portStr)
115 | if err != nil {
116 | return merry.Wrap(err)
117 | }
118 | addr := net.UDPAddr{
119 | Port: port,
120 | IP: net.ParseIP(ipStr),
121 | }
122 |
123 | ser, err := net.ListenUDP("udp", &addr)
124 | if err != nil {
125 | return merry.Wrap(err)
126 | }
127 |
128 | startTime := time.Now()
129 | requestsCount := atomic.Uint64{}
130 |
131 | log.Info().Msg("UDP: starting server on " + address)
132 | lastRequestIDs := make([]uint32, 64)
133 | for {
134 | inBuf := make([]byte, 256)
135 | n, remoteaddr, err := ser.ReadFromUDP(inBuf)
136 | if err != nil {
137 | log.Error().Err(err).Msg("UDP: reading socket")
138 | continue
139 | }
140 |
141 | payload, endpointMatches := DecodePingUDPProxyMaskedBuf(inBuf[:n], endpointPath)
142 | if !endpointMatches {
143 | log.Error().Msg("UDP: invalid payload prefix")
144 | continue
145 | }
146 |
147 | var data PingUDPProxyRequest
148 | if err := json.Unmarshal(payload, &data); err != nil {
149 | log.Error().Err(err).Msg("UDP: invalid payload data")
150 | continue
151 | }
152 |
153 | if slices.Contains(lastRequestIDs, data.RequestID) {
154 | continue //duplicate
155 | }
156 | for i := 1; i < len(lastRequestIDs); i++ {
157 | lastRequestIDs[i-1] = lastRequestIDs[i]
158 | }
159 | lastRequestIDs[len(lastRequestIDs)-1] = data.RequestID
160 |
161 | curCount := requestsCount.Add(1)
162 | if curCount%100 == 0 {
163 | log.Info().
164 | Uint64("count", curCount).
165 | Float64("rpm", float64(curCount)/float64(time.Since(startTime)/time.Second)*60).
166 | Msg("requests")
167 | }
168 |
169 | go func() {
170 | nodeID, err := storj.NodeIDFromString(data.ID)
171 | if err != nil {
172 | log.Error().Err(err).Str("raw", data.ID).Msg("UDP: invalid node ID")
173 | return
174 | }
175 |
176 | var mode SatMode
177 | if data.Mode == "tcp" {
178 | mode = SatModeTCP
179 | } else if data.Mode == "quic" {
180 | mode = SatModeQUIC
181 | } else {
182 | log.Error().Err(err).Str("raw", data.Mode).Msg("UDP: invalid mode")
183 | return
184 | }
185 |
186 | if data.Timeout <= 0 || data.Timeout > 60*1000 {
187 | log.Error().Err(err).Int64("raw", data.Timeout).Msg("UDP: invalid timeout")
188 | return
189 | }
190 |
191 | durs, err := sat.PingAndClose(data.Addr, nodeID, mode, data.DialOnly, time.Duration(data.Timeout)*time.Millisecond)
192 | var errStr string
193 | if err != nil {
194 | errStr = err.Error()
195 | }
196 |
197 | respPayload, err := json.Marshal(PingUDPProxyResponse{
198 | RequestID: data.RequestID,
199 | PingResult: PingResult{PingDurations: durs, Error: errStr},
200 | })
201 | if err != nil {
202 | log.Error().Err(err).Msg("UDP: JSON encode error")
203 | return
204 | }
205 | outBuf := EncodePingUDPProxyMaskedBuf(respPayload, endpointPath)
206 |
207 | for i := 0; i < PingUDPProxyPacketRepeat; i++ {
208 | if _, err := ser.WriteToUDP(outBuf, remoteaddr); err != nil {
209 | log.Error().Err(err).Int("iteration", i).Msg("UDP: write error")
210 | }
211 | }
212 | }()
213 | }
214 | }
215 |
216 | func DecodePingUDPProxyMaskedBuf(buf []byte, endpointPath string) ([]byte, bool) {
217 | mask := buf[0:4]
218 | payload := buf[4:]
219 | for i := range payload {
220 | payload[i] ^= mask[i%len(mask)]
221 | }
222 | if !bytes.HasPrefix(payload, []byte(endpointPath)) {
223 | return nil, false
224 | }
225 | return payload[len(endpointPath):], true
226 | }
227 |
228 | func EncodePingUDPProxyMaskedBuf(payload []byte, endpointPath string) []byte {
229 | mask := rand.Uint32()
230 | buf := make([]byte, 4+len(endpointPath)+len(payload))
231 | binary.LittleEndian.PutUint32(buf, mask)
232 | copy(buf[4:], []byte(endpointPath))
233 | copy(buf[4+len(endpointPath):], payload)
234 |
235 | maskBuf := buf[:4]
236 | outPayload := buf[4:]
237 | for i := range outPayload {
238 | outPayload[i] ^= maskBuf[i%len(maskBuf)]
239 | }
240 | return buf
241 | }
242 |
--------------------------------------------------------------------------------
/utils/db.go:
--------------------------------------------------------------------------------
1 | package utils
2 |
3 | import (
4 | "context"
5 | "net"
6 | "net/netip"
7 | "os"
8 | "path/filepath"
9 | "strings"
10 | "sync/atomic"
11 | "time"
12 |
13 | "github.com/ansel1/merry"
14 | "github.com/go-pg/pg/v10"
15 | "github.com/go-pg/pg/v10/types"
16 | "github.com/lib/pq"
17 | "github.com/oschwald/geoip2-golang"
18 | "github.com/rs/zerolog/log"
19 | )
20 |
21 | func align(sql string) string {
22 | lines := strings.Split(sql, "\n")
23 |
24 | minIndent := 999
25 | for _, line := range lines {
26 | if strings.TrimSpace(line) == "" {
27 | continue
28 | }
29 | for i, char := range line {
30 | if char != '\t' {
31 | if i < minIndent {
32 | minIndent = i
33 | }
34 | break
35 | }
36 | }
37 | }
38 |
39 | sql = ""
40 | for _, line := range lines {
41 | if strings.TrimSpace(line) != "" {
42 | sql += line[minIndent:]
43 | }
44 | sql += "\n"
45 | }
46 | return strings.TrimSpace(sql)
47 | }
48 |
49 | type dbLogger struct{}
50 |
51 | func (d dbLogger) BeforeQuery(ctx context.Context, event *pg.QueryEvent) (context.Context, error) {
52 | return ctx, nil
53 | }
54 |
55 | func (d dbLogger) AfterQuery(ctx context.Context, event *pg.QueryEvent) error {
56 | query, err := event.FormattedQuery()
57 | if err != nil {
58 | return err
59 | }
60 | log.Printf("\033[36m%s\n\033[34m%s\033[39m", time.Since(event.StartTime), align(string(query)))
61 | return nil
62 | }
63 |
64 | func MakePGConnection() *pg.DB {
65 | db := pg.Connect(&pg.Options{User: "storjnet", Password: "storj", Database: "storjnet_db"})
66 | // db.AddQueryHook(dbLogger{})
67 | return db
68 | }
69 |
70 | type GeoIPConn struct {
71 | value atomic.Value
72 | fpath string
73 | lastModTime time.Time
74 | }
75 |
76 | func OpenGeoIPConn(fpath string) (*GeoIPConn, error) {
77 | _, err := os.Stat(fpath)
78 | if err != nil && !os.IsNotExist(err) {
79 | return nil, merry.Wrap(err)
80 | }
81 | if os.IsNotExist(err) {
82 | if !filepath.IsAbs(fpath) {
83 | ex, err := os.Executable()
84 | if err != nil {
85 | return nil, merry.Wrap(err)
86 | }
87 | baseDir := filepath.Dir(ex)
88 | fpath = filepath.Clean(baseDir + "/" + fpath)
89 | }
90 | }
91 |
92 | geoip := &GeoIPConn{
93 | value: atomic.Value{},
94 | fpath: fpath,
95 | }
96 |
97 | if _, err := geoip.reopenIfUpdated(); err != nil {
98 | return nil, merry.Wrap(err)
99 | }
100 |
101 | go func() {
102 | for {
103 | reopened, err := geoip.reopenIfUpdated()
104 | if err != nil {
105 | log.Error().Err(err).Str("fpath", fpath).Msg("failed to reopen GeoIP DB, keep using old one")
106 | }
107 | if reopened {
108 | log.Debug().Str("fpath", fpath).Msg("reopened GeoIP DB connection")
109 | }
110 | time.Sleep(time.Minute)
111 | }
112 | }()
113 |
114 | return geoip, nil
115 | }
116 |
117 | func (c *GeoIPConn) reopenIfUpdated() (bool, error) {
118 | stat, err := os.Stat(c.fpath)
119 | if err != nil {
120 | return false, merry.Wrap(err)
121 | }
122 |
123 | if stat.ModTime().After(c.lastModTime) {
124 | conn, err := geoip2.Open(c.fpath)
125 | if err != nil {
126 | return false, merry.Wrap(err)
127 | }
128 | // no need to wait for old connection users and close it explictly:
129 | // the connection has finalizer and will be closed automatically
130 | // https://github.com/oschwald/geoip2-golang/issues/63#issuecomment-651125478
131 | // https://github.com/oschwald/maxminddb-golang/blob/main/reader_mmap.go#L50
132 | c.value.Store(conn)
133 | c.lastModTime = stat.ModTime()
134 | return true, nil
135 | }
136 | return false, nil
137 | }
138 |
139 | func (c *GeoIPConn) CityStr(ipStr string) (*geoip2.City, bool, error) {
140 | ipAddress := net.ParseIP(ipStr)
141 | if ipAddress == nil {
142 | return nil, false, merry.New("invalid IP: " + ipStr)
143 | }
144 | return c.City(ipAddress)
145 | }
146 |
147 | func (c *GeoIPConn) City(ipAddress net.IP) (*geoip2.City, bool, error) {
148 | conn := c.value.Load().(*geoip2.Reader)
149 | city, err := conn.City(ipAddress)
150 | if err != nil {
151 | return nil, false, merry.Wrap(err)
152 | }
153 | if city.Country.IsoCode == "" {
154 | return nil, false, nil
155 | }
156 | return city, true, nil
157 | }
158 |
159 | func (c *GeoIPConn) ASNStr(ipStr string) (*geoip2.ASN, bool, error) {
160 | ipAddress := net.ParseIP(ipStr)
161 | if ipAddress == nil {
162 | return nil, false, merry.New("invalid IP: " + ipStr)
163 | }
164 | conn := c.value.Load().(*geoip2.Reader)
165 | asn, err := conn.ASN(ipAddress)
166 | if err != nil {
167 | return nil, false, merry.Wrap(err)
168 | }
169 | if asn.AutonomousSystemNumber == 0 {
170 | return nil, false, nil
171 | }
172 | return asn, true, nil
173 | }
174 |
175 | func (c *GeoIPConn) Close() {
176 | panic("not implemented")
177 | }
178 |
179 | // because go-pg does not know anything about netip.Addr
180 | type NetAddrPG struct {
181 | netip.Addr
182 | }
183 |
184 | var _ types.ValueAppender = (*NetAddrPG)(nil)
185 |
186 | // https://github.com/go-pg/pg/blob/v10/example_custom_test.go#L13-L49
187 | func (a NetAddrPG) AppendValue(b []byte, flags int) ([]byte, error) {
188 | if flags == 1 {
189 | b = append(b, '\'')
190 | }
191 | b = a.AppendTo(b)
192 | if flags == 1 {
193 | b = append(b, '\'')
194 | }
195 | return b, nil
196 | }
197 |
198 | var _ types.ValueScanner = (*NetAddrPG)(nil)
199 |
200 | // https://github.com/go-pg/pg/blob/v10/example_custom_test.go#L13-L49
201 | func (a *NetAddrPG) ScanValue(rd types.Reader, n int) error {
202 | if n <= 0 {
203 | a.Addr = netip.Addr{}
204 | return nil
205 | }
206 |
207 | tmp, err := rd.ReadFullTemp()
208 | if err != nil {
209 | return err
210 | }
211 |
212 | a.Addr, err = netip.ParseAddr(string(tmp))
213 | if err != nil {
214 | return err
215 | }
216 | return nil
217 | }
218 |
219 | func (a NetAddrPG) GE(b NetAddrPG) bool {
220 | return !a.Less(b.Addr)
221 | }
222 |
223 | func (a NetAddrPG) LE(b NetAddrPG) bool {
224 | return !b.Less(a.Addr)
225 | }
226 |
227 | func IsConstrError(err error, table, kind, name string) bool {
228 | if perr, ok := merry.Unwrap(err).(pg.Error); ok {
229 | return perr.Field('t') == table &&
230 | pq.ErrorCode(perr.Field('C')).Name() == kind &&
231 | perr.Field('n') == name
232 | }
233 | return false
234 | }
235 |
236 | func PrintPGErrInfo(err error) {
237 | perr := err.(pg.Error)
238 | for c := byte('A'); c <= byte('z'); c++ {
239 | if perr.Field(c) != "" {
240 | println(c, string(c), perr.Field(c))
241 | }
242 | }
243 | }
244 |
245 | func SaveChunked(db *pg.DB, chunkSize int, channel chan interface{}, handler func(tx *pg.Tx, items []interface{}) error) error {
246 | var err error
247 | items := make([]interface{}, 0, chunkSize)
248 | for item := range channel {
249 | items = append(items, item)
250 | if len(items) >= chunkSize {
251 | err = db.RunInTransaction(context.Background(), func(tx *pg.Tx) error {
252 | return merry.Wrap(handler(tx, items))
253 | })
254 | if err != nil {
255 | return merry.Wrap(err)
256 | }
257 | items = items[:0]
258 | }
259 | }
260 | if len(items) > 0 {
261 | err = db.RunInTransaction(context.Background(), func(tx *pg.Tx) error {
262 | return merry.Wrap(handler(tx, items))
263 | })
264 | }
265 | return merry.Wrap(err)
266 | }
267 |
--------------------------------------------------------------------------------
/www/src/components/ping_my_node.js:
--------------------------------------------------------------------------------
1 | import { apiReq } from 'src/api'
2 | import { isAbortError, onError } from 'src/errors'
3 | import { lang } from 'src/i18n'
4 | import { bindHandlers, getJSONContent } from 'src/utils/elems'
5 | import { html } from 'src/utils/htm'
6 | import { PingModeDescription } from 'src/utils/nodes'
7 | import { PureComponent } from 'src/utils/preact_compat'
8 |
9 | import './ping_my_node.css'
10 |
11 | /** @typedef {{id:string, address:string}} PingNode */
12 | /** @typedef {{num:number, label:string, quic:boolean}} UsabelSatelliteInfo */
13 |
14 | /** @type {UsabelSatelliteInfo[]} */
15 | let usableSatellites = [{ num: 0, label: '???', quic: true }]
16 | try {
17 | usableSatellites = getJSONContent('usable_satellites')
18 | } catch (ex) {
19 | // ¯\_(ツ)_/¯
20 | }
21 |
22 | /**
23 | * @class
24 | * @typedef PMN_State
25 | * @prop {string} logText
26 | * @prop {PingNode[]} pingedNodes
27 | * @prop {PingNode} curNode
28 | * @prop {boolean} pending
29 | * @extends {PureComponent<{}, PMN_State>}
30 | */
31 | export class PingMyNode extends PureComponent {
32 | constructor() {
33 | super()
34 | let pingedNodes = []
35 | try {
36 | if (localStorage.pingedNodes) pingedNodes = JSON.parse(localStorage.pingedNodes)
37 | } catch (ex) {
38 | // ¯\_(ツ)_/¯
39 | }
40 | /** @type {PMN_State} */
41 | this.state = { pingedNodes, curNode: { id: '', address: '' }, logText: '', pending: false }
42 | /** @type {AbortController|null} */
43 | this.pingAbortController = null
44 | bindHandlers(this)
45 | }
46 |
47 | addLogLine(msg) {
48 | this.setState(({ logText }) => ({ logText: logText + '- ' + msg + '\n' }))
49 | }
50 | /**
51 | * @param {boolean} dialOnly
52 | * @param {'tcp'|'quic'} mode
53 | * @param {number} satelliteNum
54 | * @param {AbortController} abortController
55 | * @returns {Promise<{aborted:boolean}>}
56 | */
57 | pingMode(dialOnly, mode, satelliteNum, abortController) {
58 | let { id, address } = this.state.curNode
59 | if (id === '' || address === '') return Promise.resolve({ aborted: false })
60 |
61 | this.rememberNode(id, address)
62 | let log = msg => this.addLogLine(mode.toUpperCase() + ': ' + msg)
63 |
64 | return apiReq('POST', '/api/ping_my_node', {
65 | data: { id, address, dialOnly, mode, satelliteNum },
66 | signal: abortController.signal,
67 | })
68 | .then(resp => {
69 | let { dialDuration, pingDuration } = resp
70 | const ms = seconds => (seconds * 1000).toFixed() + 'ms'
71 | log(`dialed node in ${ms(dialDuration)}`)
72 | if (!dialOnly) {
73 | log(`pinged node in ${ms(pingDuration)}`)
74 | log(`total: ${ms(pingDuration + dialDuration)}`)
75 | }
76 | return { aborted: false }
77 | })
78 | .catch(err => {
79 | switch (err.error) {
80 | case 'NODE_ID_DECODE_ERROR':
81 | log('wrong node ID: ' + err.description)
82 | break
83 | case 'NODE_DIAL_ERROR':
84 | log("couldn't connect to node: " + err.description)
85 | break
86 | case 'NODE_PING_ERROR':
87 | log("couldn't ping node: " + err.description)
88 | break
89 | default:
90 | if (isAbortError(err)) {
91 | log('aborted')
92 | } else {
93 | log('O_o ' + JSON.stringify(err))
94 | onError(err)
95 | }
96 | }
97 | return { aborted: isAbortError(err) }
98 | })
99 | }
100 | /**
101 | * @param {boolean} dialOnly
102 | */
103 | async pingAllModes(dialOnly) {
104 | this.setState({ pending: true, logText: '' })
105 |
106 | if (this.pingAbortController !== null) this.pingAbortController.abort()
107 | let abortController = (this.pingAbortController = new AbortController())
108 |
109 | this.addLogLine('started')
110 | this.addLogLine('')
111 |
112 | try {
113 | for (const sat of usableSatellites) {
114 | this.addLogLine('from: ' + sat.label)
115 |
116 | /** @type {Promise<{aborted:boolean}>[]} */
117 | let promises = []
118 | promises.push(this.pingMode(dialOnly, 'tcp', sat.num, abortController))
119 | promises.push(this.pingMode(dialOnly, 'quic', sat.num, abortController))
120 | await Promise.all(promises)
121 |
122 | this.addLogLine('')
123 | }
124 | } finally {
125 | this.setState({ pending: false })
126 | this.pingAbortController = null
127 | }
128 |
129 | this.addLogLine('done.')
130 | }
131 | rememberNode(id, address) {
132 | let nodes = this.state.pingedNodes
133 | if (!nodes.find(n => n.id === id && n.address === address)) {
134 | nodes = nodes.slice()
135 | nodes.push({ id, address })
136 | this.setState({ pingedNodes: nodes })
137 | }
138 | }
139 | forgetNode(id, address) {
140 | this.setState({
141 | pingedNodes: this.state.pingedNodes.filter(n => n.id !== id || n.address !== address),
142 | })
143 | }
144 |
145 | onNodeClick(e) {
146 | let elem = e.target.closest('.item')
147 | this.setState({
148 | curNode: { id: elem.dataset.id, address: elem.dataset.address },
149 | })
150 | }
151 | onNodeRemoveClick(e) {
152 | let elem = e.target.closest('.item')
153 | this.forgetNode(elem.dataset.id, elem.dataset.address)
154 | }
155 | onDialClick() {
156 | this.pingAllModes(true)
157 | }
158 | onPingClick() {
159 | this.pingAllModes(false)
160 | }
161 | onCurNodeIDUpdate(e) {
162 | this.setState({ curNode: { ...this.state.curNode, id: e.target.value.trim() } })
163 | }
164 | onCurNodeAddressUpdate(e) {
165 | this.setState({ curNode: { ...this.state.curNode, address: e.target.value.trim() } })
166 | }
167 |
168 | componentDidUpdate(prevProps, prevState) {
169 | localStorage.pingedNodes = JSON.stringify(this.state.pingedNodes)
170 | }
171 |
172 | /**
173 | * @param {{}} props
174 | * @param {PMN_State} state
175 | */
176 | render(props, { pingedNodes, curNode, logText, pending }) {
177 | return html`
178 |
179 | ${pingedNodes.map(
180 | node => html`
181 |
188 | `,
189 | )}
190 |
193 | ${lang === 'ru' ? 'Будут проверены и TCP, и ' : 'Will try both TCP and '}
194 | QUIC .
195 |
196 |
212 | ${logText}
213 | `
214 | }
215 | }
216 |
--------------------------------------------------------------------------------
/core/versions.go:
--------------------------------------------------------------------------------
1 | package core
2 |
3 | import (
4 | "encoding/json"
5 | "fmt"
6 | "io"
7 | "net/http"
8 |
9 | "github.com/ansel1/merry"
10 | "github.com/blang/semver"
11 | "github.com/go-pg/pg/v10"
12 | "github.com/rs/zerolog/log"
13 | )
14 |
15 | type prefixedVersion semver.Version
16 |
17 | func (v *prefixedVersion) UnmarshalJSON(data []byte) (err error) {
18 | var versionString string
19 | if err = json.Unmarshal(data, &versionString); err != nil {
20 | return merry.Wrap(err)
21 | }
22 | if versionString[0] == 'v' {
23 | versionString = versionString[1:]
24 | }
25 | sv, err := semver.Parse(versionString)
26 | if err != nil {
27 | return merry.Wrap(err)
28 | }
29 | *v = prefixedVersion(sv)
30 | return nil
31 | }
32 |
33 | var GitHubOAuthToken = ""
34 |
35 | type VersionChecker interface {
36 | Key() string
37 | FetchPrevVersion() error
38 | FetchCurVersion() error
39 | VersionHasChanged() bool
40 | SaveCurVersion() error
41 | DebugVersions() (string, string)
42 | MessageNew() string
43 | MessageCur() string
44 | }
45 |
46 | type CurVersionChecker interface {
47 | Key() string
48 | FetchCurVersion() error
49 | MessageCur() string
50 | }
51 |
52 | type Cursor string
53 |
54 | func (c Cursor) String() string {
55 | if len(c) > 7 {
56 | c = c[:3] + "…" + c[len(c)-3:]
57 | }
58 | return string(c)
59 | }
60 |
61 | func (c Cursor) IsFinal() bool {
62 | for _, char := range c {
63 | if char != 'f' {
64 | return false
65 | }
66 | }
67 | return len(c) > 0
68 | }
69 |
70 | type VersionWithCursor struct {
71 | Version semver.Version
72 | Cursor Cursor
73 | }
74 |
75 | func (v VersionWithCursor) VString() string {
76 | return fmt.Sprintf("v%s, cursor: %s", v.Version, v.Cursor)
77 | }
78 |
79 | type StrojIoVersionChecker struct {
80 | db *pg.DB
81 | prevVersion VersionWithCursor
82 | curVersion VersionWithCursor
83 | }
84 |
85 | func (c *StrojIoVersionChecker) Key() string {
86 | return "StorjIo:storagenode"
87 | }
88 |
89 | func (c *StrojIoVersionChecker) FetchPrevVersion() error {
90 | _, err := c.db.QueryOne(&c.prevVersion,
91 | `SELECT version, extra->>'cursor' AS cursor FROM versions WHERE kind = ? ORDER BY created_at DESC LIMIT 1`,
92 | c.Key())
93 | if err != nil && err != pg.ErrNoRows {
94 | return merry.Wrap(err)
95 | }
96 | return nil
97 | }
98 |
99 | func (c *StrojIoVersionChecker) SaveCurVersion() error {
100 | _, err := c.db.Exec(`INSERT INTO versions (kind, version, extra) VALUES (?, ?, json_build_object('cursor', ?))`,
101 | c.Key(), c.curVersion.Version, string(c.curVersion.Cursor))
102 | return merry.Wrap(err)
103 | }
104 |
105 | func (c *StrojIoVersionChecker) FetchCurVersion() error {
106 | resp, err := http.Get("https://version.storj.io/")
107 | if err != nil {
108 | return merry.Wrap(err)
109 | }
110 | defer resp.Body.Close()
111 | params := &struct {
112 | Processes struct {
113 | Storagenode struct {
114 | Suggested struct{ Version semver.Version }
115 | Rollout struct{ Cursor string }
116 | }
117 | }
118 | }{}
119 | if err := json.NewDecoder(resp.Body).Decode(¶ms); err != nil {
120 | return merry.Wrap(err)
121 | }
122 | c.curVersion.Version = params.Processes.Storagenode.Suggested.Version
123 | c.curVersion.Cursor = Cursor(params.Processes.Storagenode.Rollout.Cursor)
124 | return nil
125 | }
126 |
127 | func (c *StrojIoVersionChecker) VersionHasChanged() bool {
128 | return !c.curVersion.Version.Equals(c.prevVersion.Version) ||
129 | (c.curVersion.Cursor != c.prevVersion.Cursor && c.curVersion.Cursor.IsFinal())
130 | }
131 |
132 | func (c *StrojIoVersionChecker) DebugVersions() (string, string) {
133 | return c.prevVersion.VString(), c.curVersion.VString()
134 | }
135 |
136 | func (c *StrojIoVersionChecker) MessageNew() string {
137 | if c.curVersion.Version.Equals(c.prevVersion.Version) && c.curVersion.Cursor.IsFinal() {
138 | return fmt.Sprintf("Финальный курсор *%s* (v%s) на version.storj.io",
139 | c.curVersion.Cursor, c.curVersion.Version)
140 | }
141 | return fmt.Sprintf("Новая версия *v%s* (cursor: %s)\nРекомендуемая для нод на version.storj.io",
142 | c.curVersion.Version, c.curVersion.Cursor)
143 | }
144 |
145 | func (c *StrojIoVersionChecker) MessageCur() string {
146 | return fmt.Sprintf("%s (version.storj.io)", c.curVersion.VString())
147 | }
148 |
149 | type GitHubVersionChecker struct {
150 | db *pg.DB
151 | prevVersion semver.Version
152 | curVersion semver.Version
153 | }
154 |
155 | func (c *GitHubVersionChecker) Key() string {
156 | return "GitHub:latest"
157 | }
158 |
159 | func (c *GitHubVersionChecker) FetchPrevVersion() error {
160 | _, err := c.db.QueryOne(pg.Scan(&c.prevVersion),
161 | `SELECT version FROM versions WHERE kind = ? ORDER BY created_at DESC LIMIT 1`, c.Key())
162 | if err != nil && err != pg.ErrNoRows {
163 | return merry.Wrap(err)
164 | }
165 | return nil
166 | }
167 |
168 | func (c *GitHubVersionChecker) SaveCurVersion() error {
169 | _, err := c.db.Exec(`INSERT INTO versions (kind, version) VALUES (?, ?)`, c.Key(), c.curVersion)
170 | return merry.Wrap(err)
171 | }
172 |
173 | func (c *GitHubVersionChecker) FetchCurVersion() error {
174 | req, err := http.NewRequest("GET", "https://api.github.com/repos/storj/storj/releases/latest", nil)
175 | if err != nil {
176 | return merry.Wrap(err)
177 | }
178 | if GitHubOAuthToken != "" {
179 | req.Header.Set("Authorization", "token "+GitHubOAuthToken)
180 | }
181 | resp, err := http.DefaultClient.Do(req)
182 | if err != nil {
183 | return merry.Wrap(err)
184 | }
185 | defer resp.Body.Close()
186 | params := &struct {
187 | Name string
188 | TagName prefixedVersion `json:"tag_name"`
189 | }{}
190 | // if err := json.NewDecoder(resp.Body).Decode(¶ms); err != nil {
191 | // return merry.Wrap(err)
192 | // }
193 | buf, err := io.ReadAll(resp.Body)
194 | if err != nil {
195 | return merry.Wrap(err)
196 | }
197 | if err := json.Unmarshal(buf, ¶ms); err != nil {
198 | return merry.Wrap(err)
199 | }
200 | if semver.Version(params.TagName).Equals(semver.Version{}) {
201 | log.Warn().Str("resp", string(buf)).Msg("version is zero")
202 | return merry.New("version is zero")
203 | }
204 | c.curVersion = semver.Version(params.TagName)
205 | return nil
206 | }
207 |
208 | func (c *GitHubVersionChecker) VersionHasChanged() bool {
209 | // GitHub sometimes starts returning a previous version for a short period.
210 | // So ignoring the version downgrade here.
211 | return c.curVersion.GT(c.prevVersion)
212 | // return !c.curVersion.Equals(c.prevVersion)
213 | }
214 |
215 | func (c *GitHubVersionChecker) DebugVersions() (string, string) {
216 | return "v" + c.prevVersion.String(), "v" + c.curVersion.String()
217 | }
218 |
219 | func (c *GitHubVersionChecker) MessageNew() string {
220 | return fmt.Sprintf("Новый релиз *v%s*\nНа [ГитХабе](https://github.com/storj/storj/releases/tag/v%s), с ченджлогом и бинарниками.", c.curVersion, c.curVersion)
221 | }
222 |
223 | func (c *GitHubVersionChecker) MessageCur() string {
224 | return fmt.Sprintf("v%s ([GitHub](https://github.com/storj/storj/releases/tag/v%s))", c.curVersion, c.curVersion)
225 | }
226 |
227 | func MakeCurVersionCheckers() []CurVersionChecker {
228 | return []CurVersionChecker{&StrojIoVersionChecker{}, &GitHubVersionChecker{}}
229 | }
230 |
231 | func MakeVersionCheckers(db *pg.DB) []VersionChecker {
232 | return []VersionChecker{&StrojIoVersionChecker{db: db}, &GitHubVersionChecker{db: db}}
233 | }
234 |
--------------------------------------------------------------------------------
/nodes/prober.go:
--------------------------------------------------------------------------------
1 | package nodes
2 |
3 | import (
4 | "context"
5 | "storjnet/utils"
6 | "storjnet/utils/storjutils"
7 | "strconv"
8 | "strings"
9 | "sync"
10 | "sync/atomic"
11 | "time"
12 |
13 | "github.com/ansel1/merry"
14 | "github.com/go-pg/pg/v10"
15 | "github.com/rs/zerolog/log"
16 | "storj.io/common/storj"
17 | )
18 |
19 | const (
20 | nodesUpdateInterval = `INTERVAL '8 minutes'`
21 | noNodesPauseDuraton = 30 * time.Second
22 | probeRoutinesCount = 64
23 | )
24 |
25 | type ProbeNode struct {
26 | RawID []byte
27 | ID storj.NodeID
28 | IPAddr string
29 | Port uint16
30 | }
31 | type ProbeNodeErr struct {
32 | Node *ProbeNode
33 | TCPErr error
34 | QUICErr error
35 | }
36 |
37 | func errIsKnown(err error) bool {
38 | msg := err.Error()
39 | return strings.HasPrefix(msg, "rpc: context deadline exceeded") ||
40 | (strings.HasPrefix(msg, "rpc: dial tcp ") &&
41 | (strings.Contains(msg, ": connect: connection refused") ||
42 | strings.Contains(msg, ": connect: no route to host") ||
43 | strings.Contains(msg, ": i/o timeout"))) ||
44 | (strings.HasPrefix(msg, "rpc: socks connect") &&
45 | (strings.HasSuffix(msg, "connection refused") ||
46 | strings.HasSuffix(msg, "host unreachable") ||
47 | strings.Contains(msg, ": i/o timeout"))) ||
48 | strings.HasPrefix(msg, "rpc: tls peer certificate verification error: tlsopts: peer ID did not match requested ID")
49 | }
50 |
51 | func probeWithTimeout(sats storjutils.Satellites, nodeID storj.NodeID, address string, mode storjutils.SatMode) (storjutils.Satellite, error) {
52 | sat, err := sats.DialAndClose(address, nodeID, mode, 5*time.Second)
53 | return sat, merry.Wrap(err)
54 | }
55 | func probe(sats storjutils.Satellites, node *ProbeNode) (tcpSat, quicSat storjutils.Satellite, tcpErr error, quicErr error) {
56 | address := node.IPAddr + ":" + strconv.Itoa(int(node.Port))
57 | wg := sync.WaitGroup{}
58 |
59 | wg.Add(2)
60 | go func() {
61 | tcpSat, tcpErr = probeWithTimeout(sats, node.ID, address, storjutils.SatModeTCP)
62 | wg.Done()
63 | }()
64 | go func() {
65 | quicSat, quicErr = probeWithTimeout(sats, node.ID, address, storjutils.SatModeQUIC)
66 | wg.Done()
67 | }()
68 |
69 | wg.Wait()
70 | return
71 | }
72 |
73 | func startOldNodesLoader(db *pg.DB, nodesChan chan *ProbeNode, chunkSize int) utils.Worker {
74 | worker := utils.NewSimpleWorker(1)
75 |
76 | go func() {
77 | defer worker.Done()
78 | for {
79 | nodes := make([]*ProbeNode, chunkSize)
80 | err := db.RunInTransaction(context.Background(), func(tx *pg.Tx) error {
81 | _, err := tx.Query(&nodes, `
82 | SELECT id AS raw_id, ip_addr, port FROM nodes
83 | WHERE checked_at IS NULL
84 | OR (checked_at < NOW() - `+nodesUpdateInterval+`
85 | AND greatest(updated_at, last_received_from_sat_at) > NOW() - INTERVAL '7 days')
86 | ORDER BY checked_at ASC NULLS FIRST
87 | LIMIT ?
88 | FOR UPDATE`, chunkSize)
89 | if err != nil {
90 | return merry.Wrap(err)
91 | }
92 | if len(nodes) == 0 {
93 | return nil
94 | }
95 | for _, node := range nodes {
96 | node.ID, err = storj.NodeIDFromBytes(node.RawID)
97 | if err != nil {
98 | return merry.Wrap(err)
99 | }
100 | }
101 | nodeIDs := make(storj.NodeIDList, len(nodes))
102 | for i, node := range nodes {
103 | nodeIDs[i] = node.ID
104 | }
105 | _, err = tx.Exec(`UPDATE nodes SET checked_at = NOW() WHERE id IN (?)`, pg.In(nodeIDs))
106 | return merry.Wrap(err)
107 | })
108 | if err != nil {
109 | worker.AddError(err)
110 | return
111 | }
112 |
113 | log.Info().Int("IDs count", len(nodes)).Msg("PROBE:OLD")
114 | if len(nodes) == 0 {
115 | time.Sleep(noNodesPauseDuraton)
116 | }
117 | for _, node := range nodes {
118 | nodesChan <- node
119 | }
120 | }
121 | }()
122 | return worker
123 | }
124 |
125 | func startNodesProber(nodesInChan chan *ProbeNode, nodesOutChan chan *ProbeNodeErr, routinesCount int) utils.Worker {
126 | worker := utils.NewSimpleWorker(routinesCount)
127 |
128 | sats, err := storjutils.SatellitesSetUpFromEnv()
129 | if err != nil {
130 | worker.AddError(err)
131 | return worker
132 | }
133 |
134 | stamp := time.Now().Unix()
135 | countTotal := int64(0)
136 | countOk := int64(0)
137 | countTCPProxyOk := int64(0)
138 | countQUICProxyOk := int64(0)
139 | countErr := int64(0)
140 | for i := 0; i < routinesCount; i++ {
141 | go func() {
142 | defer worker.Done()
143 | for node := range nodesInChan {
144 | tcpSat, quicSat, tcpErr, quicErr := probe(sats, node)
145 | if tcpErr != nil && quicErr != nil {
146 | atomic.AddInt64(&countErr, 1)
147 | if !errIsKnown(tcpErr) {
148 | log.Info().Str("id", node.ID.String()).Msg(tcpErr.Error())
149 | }
150 | } else {
151 | if tcpSat != nil && tcpSat.UsesProxy() {
152 | atomic.AddInt64(&countTCPProxyOk, 1)
153 | }
154 | if quicSat != nil && quicSat.UsesProxy() {
155 | atomic.AddInt64(&countQUICProxyOk, 1)
156 | }
157 | atomic.AddInt64(&countOk, 1)
158 | nodesOutChan <- &ProbeNodeErr{Node: node, TCPErr: tcpErr, QUICErr: quicErr}
159 | }
160 |
161 | if atomic.AddInt64(&countTotal, 1)%100 == 0 {
162 | log.Info().
163 | Int64("total", countTotal).
164 | Int64("ok", countOk).Int64("tcpProxyOk", countTCPProxyOk).Int64("quicProxyOk", countQUICProxyOk).
165 | Int64("err", countErr).
166 | Float64("rpm", float64(countTotal)/float64(time.Now().Unix()-stamp)*60).
167 | Msg("PROBE:GET")
168 | }
169 | }
170 | }()
171 | }
172 | return worker
173 | }
174 |
175 | func startPingedNodesSaver(db *pg.DB, nodesChan chan *ProbeNodeErr, chunkSize int) utils.Worker {
176 | worker := utils.NewSimpleWorker(1)
177 | nodesChanI := make(chan interface{}, 16)
178 |
179 | go func() {
180 | for node := range nodesChan {
181 | nodesChanI <- node
182 | }
183 | close(nodesChanI)
184 | }()
185 |
186 | go func() {
187 | defer worker.Done()
188 | err := utils.SaveChunked(db, chunkSize, nodesChanI, func(tx *pg.Tx, items []interface{}) error {
189 | ids := make([]storj.NodeID, len(items))
190 | tcpErrIDs := make([]storj.NodeID, 0, len(items))
191 | quicErrIDs := make([]storj.NodeID, 0, len(items))
192 | for i, nodeI := range items {
193 | n := nodeI.(*ProbeNodeErr)
194 | ids[i] = n.Node.ID
195 | if n.TCPErr != nil {
196 | tcpErrIDs = append(tcpErrIDs, n.Node.ID)
197 | }
198 | if n.QUICErr != nil {
199 | quicErrIDs = append(quicErrIDs, n.Node.ID)
200 | }
201 | }
202 | _, err := tx.Exec(`
203 | UPDATE nodes SET
204 | updated_at = NOW(),
205 | tcp_updated_at = CASE WHEN id = any(ARRAY[?]::bytea[]) THEN tcp_updated_at ELSE NOW() END,
206 | quic_updated_at = CASE WHEN id = any(ARRAY[?]::bytea[]) THEN quic_updated_at ELSE NOW() END
207 | WHERE id IN (?)`,
208 | pg.In(tcpErrIDs), pg.In(quicErrIDs), pg.In(ids))
209 | if err != nil {
210 | return merry.Wrap(err)
211 | }
212 | return nil
213 | })
214 | log.Info().Msg("PROBE:SAVE:DONE")
215 | if err != nil {
216 | worker.AddError(err)
217 | }
218 | }()
219 | return worker
220 | }
221 |
222 | func StartProber() error {
223 | db := utils.MakePGConnection()
224 | nodesInChan := make(chan *ProbeNode, 32)
225 | nodesOutChan := make(chan *ProbeNodeErr, 32)
226 |
227 | workers := []utils.Worker{
228 | startOldNodesLoader(db, nodesInChan, 128),
229 | startNodesProber(nodesInChan, nodesOutChan, probeRoutinesCount),
230 | startPingedNodesSaver(db, nodesOutChan, 32),
231 | }
232 |
233 | iter := 0
234 | for {
235 | for _, worker := range workers {
236 | if err := worker.PopError(); err != nil {
237 | return err
238 | }
239 | }
240 |
241 | iter += 1
242 | if iter%5 == 0 {
243 | log.Info().Int("in_chan", len(nodesInChan)).Int("out_chan", len(nodesOutChan)).Msg("PROBE:STAT")
244 | }
245 |
246 | time.Sleep(time.Second)
247 | }
248 | }
249 |
--------------------------------------------------------------------------------
/www/src/components/nodes_subnet_summary.js:
--------------------------------------------------------------------------------
1 | import { memo } from 'src/utils/preact_compat'
2 | import { html } from 'src/utils/htm'
3 | import { L, lang } from 'src/i18n'
4 | import { useCallback, useEffect, useMemo, useState } from 'preact/hooks'
5 | import { apiReq } from 'src/api'
6 | import { toISODateString, useHashInterval } from 'src/utils/time'
7 | import { onError } from 'src/errors'
8 | import { zeroes } from 'src/utils/arrays'
9 |
10 | import './nodes_subnet_summary.css'
11 | import { THINSP } from 'src/utils/elems'
12 |
13 | const SIZES_STATS_COUNTS = [1, 2, 3, 10, 100]
14 |
15 | /**
16 | * @typedef {{
17 | * subnetsCount: number,
18 | * subnetsTop: {subnet:string, size:number}[],
19 | * subnetSizes: {size:number, count:number}[],
20 | * ipTypes: {type:string, count:number, asnTop:{name:string, count:number}[]}[],
21 | * }} NodesSubnetsSummaryResponse
22 | */
23 |
24 | const NodesSummary = memo(function NodesSummary() {
25 | const [stats, setStats] = useState(/** @type {NodesSubnetsSummaryResponse | null} */ (null))
26 | const [, endDate] = useHashInterval()
27 |
28 | useEffect(() => {
29 | const abortController = new AbortController()
30 |
31 | apiReq('GET', `/api/nodes/subnet_summary`, {
32 | data: { end_date: toISODateString(endDate) },
33 | signal: abortController.signal,
34 | })
35 | .then(stats => {
36 | setStats(stats)
37 | })
38 | .catch(onError)
39 |
40 | return () => abortController.abort()
41 | }, [endDate])
42 |
43 | const subnetsCount = stats ? stats.subnetsCount : 0
44 |
45 | return html`
46 |
47 | <${NodesSubnetsSummaryTable} subnetsTop=${stats?.subnetsTop} />
48 | <${NodesSubnetsSizesTable} subnetSizes=${stats?.subnetSizes} />
49 | <${NodesIPTypesTable} ipTypes=${stats?.ipTypes} />
50 |
51 |
52 | ${lang === 'ru'
53 | ? `Ноды запущены как минимум в ${L.n(subnetsCount, 'подсети', 'подсетях', 'подсетях')} /24.`
54 | : `Nodes are running in at least ${L.n(subnetsCount, 'subnet', 'subnets')} /24.`}
55 |
56 | `
57 | })
58 |
59 | /** @param {{subnetsTop: undefined | NodesSubnetsSummaryResponse['subnetsTop']}} props */
60 | function NodesSubnetsSummaryTable({ subnetsTop }) {
61 | return html`
62 |
63 |
64 | ${L('#', 'ru', '№')}
65 | ${L('Subnet', 'ru', 'Подсеть')}
66 |
67 | ${L('Nodes', 'ru', 'Нод')}
68 | ${L('in subnet', 'ru', 'в подсети')}
69 |
70 |
71 |
72 |
73 | ${!subnetsTop
74 | ? zeroes(5).map(
75 | (_, i) => html`
76 | ${i + 1}
77 | ${L('loading…', 'ru', 'загрузка…')}
78 | …
79 | `,
80 | )
81 | : subnetsTop.map(
82 | (item, i) =>
83 | html`
84 | ${i + 1}
85 | <${Subnet} subnet=${item.subnet} />
86 | ${item.size}
87 | `,
88 | )}
89 |
90 | …
92 |
94 |
95 |
`
96 | }
97 |
98 | /** @param {{subnetSizes: undefined | NodesSubnetsSummaryResponse['subnetSizes']}} props */
99 | function NodesSubnetsSizesTable({ subnetSizes }) {
100 | const [isExpanded, setIsExpanded] = useState(false)
101 |
102 | const onExpand = useCallback(() => {
103 | setIsExpanded(true)
104 | }, [])
105 |
106 | const sizesStats = useMemo(() => {
107 | if (!subnetSizes) return null
108 |
109 | if (isExpanded) {
110 | return subnetSizes.map(x => ({ label: x.size + '', count: x.count }))
111 | } else {
112 | return SIZES_STATS_COUNTS.map((count, i, counts) => {
113 | const nextCount = counts[i + 1] || Infinity
114 | return {
115 | label:
116 | count === nextCount - 1
117 | ? count + ''
118 | : nextCount === Infinity
119 | ? count + '+'
120 | : html`${count}–${nextCount - 1} `,
121 | count: subnetSizes
122 | .filter(x => x.size >= count && x.size < nextCount)
123 | .map(x => x.count)
124 | .reduce((a, b) => a + b, 0),
125 | }
126 | }).filter(x => x.count > 0)
127 | }
128 | }, [subnetSizes, isExpanded])
129 |
130 | return html`
131 |
132 |
133 |
134 | ${L('Nodes', 'ru', 'Нод')}
135 | ${L('in subnet', 'ru', 'в подсети')}
136 |
137 |
138 | ${L('Count', 'ru', 'Кол-во')}
139 | ${L('of subnets', 'ru', 'подсетей')}
140 |
141 |
142 |
143 |
144 | ${sizesStats === null
145 | ? zeroes(SIZES_STATS_COUNTS.length).map(
146 | x =>
147 | html`
148 | ${L('loading…', 'ru', 'загрузка…')}
149 | `,
150 | )
151 | : sizesStats.map(
152 | (item, i) =>
153 | html`
154 | ${item.label}
155 | ${item.count}
156 | `,
157 | )}
158 |
159 | ${!isExpanded &&
160 | sizesStats &&
161 | sizesStats.length > 0 &&
162 | html`
163 |
164 | ${L('Expand', 'ru', 'Развернуть')}
165 |
166 | `}
167 |
168 |
169 |
`
170 | }
171 |
172 | /** @param {{ipTypes: undefined | NodesSubnetsSummaryResponse['ipTypes']}} props */
173 | function NodesIPTypesTable({ ipTypes }) {
174 | const [expanded, setExpanded] = useState(/**@type {Record}*/ ({}))
175 |
176 | const toggle = useCallback((/**@type {string}*/ type) => {
177 | setExpanded(expanded => {
178 | expanded = { ...expanded }
179 | if (expanded[type]) {
180 | delete expanded[type]
181 | } else {
182 | expanded[type] = true
183 | }
184 | return expanded
185 | })
186 | }, [])
187 |
188 | return html`
189 |
190 |
191 |
192 | ${Object.keys(expanded).length > 0 &&
193 | html`${L('Name', 'ru', 'Название')}
194 | ${L('of AS', 'ru', "AS'ки")}
`}
195 |
196 |
197 | ${L('Type', 'ru', 'Тип')}
198 | ${L('of IP-addr', 'ru', 'IP-адреса')}
199 |
200 |
201 | ${L('Nodes', 'ru', 'Кол-во')}
202 | ${L('count', 'ru', 'нод')}
203 |
204 |
205 |
206 |
207 | ${!ipTypes
208 | ? zeroes(4).map(
209 | (_, i) => html`
210 | ${L('loading…', 'ru', 'загрузка…')}
211 | `,
212 | )
213 | : ipTypes.map(item => {
214 | const isExpanded = !!expanded[item.type]
215 | const isTruncated = item.count > item.asnTop.reduce((a, b) => a + b.count, 0)
216 | return html`
217 |
219 | toggle(item.type)}>
220 | ${isExpanded ? '⏷' : '⏵'}${THINSP}${item.type}
221 |
222 |
223 | ${item.count}
224 |
225 | ${isExpanded &&
226 | item.asnTop.map(
227 | x =>
228 | html`
229 | ${x.name}
230 | ${x.count}
231 | `,
232 | )}
233 | ${isExpanded &&
234 | isTruncated &&
235 | html`
236 | …
238 | `}`
240 | })}
241 |
242 |
`
243 | }
244 |
245 | /** @param {{subnet:string}} props */
246 | function Subnet({ subnet }) {
247 | return subnet.endsWith('.0') ? html`${subnet.slice(0, -2)}.0 ` : subnet
248 | }
249 |
250 | export const NodesSubnetSummary = memo(function NodesSubnetSummary() {
251 | return html`
252 | ${L('By subnets', 'ru', 'По подсетям')}
253 | <${NodesSummary} />
254 | `
255 | })
256 |
--------------------------------------------------------------------------------
/tgbot/tgbot.go:
--------------------------------------------------------------------------------
1 | package tgbot
2 |
3 | import (
4 | "context"
5 | "net/http"
6 | "net/url"
7 | "storjnet/core"
8 | "storjnet/utils"
9 | "strconv"
10 | "strings"
11 |
12 | "github.com/ansel1/merry"
13 | "github.com/go-pg/pg/v10"
14 | tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api"
15 | "github.com/rs/zerolog/log"
16 | "golang.org/x/net/proxy"
17 | )
18 |
19 | var ErrActionNotAllowed = merry.New("action not allowed")
20 |
21 | type cmdHandler func(*tgbotapi.BotAPI, *pg.DB, tgbotapi.Update, string) error
22 |
23 | type WebhookConfig struct {
24 | URL string
25 | ListenAddr string
26 | ListenPath string
27 | }
28 |
29 | func isReplyToBotInGroupChat(bot *tgbotapi.BotAPI, update tgbotapi.Update) bool {
30 | msg := update.Message
31 | if msg == nil || msg.From == nil || msg.ReplyToMessage == nil || msg.ReplyToMessage.From == nil {
32 | return false
33 | }
34 | return int64(msg.From.ID) != msg.Chat.ID && msg.ReplyToMessage.From.ID == bot.Self.ID
35 | }
36 |
37 | func justSend(bot *tgbotapi.BotAPI, chatID int64, text string) error {
38 | return merry.Wrap(utils.TGSendMessageMD(bot, chatID, text))
39 | }
40 |
41 | func extractCommand(bot *tgbotapi.BotAPI, update tgbotapi.Update) (string, string) {
42 | m := update.Message
43 | if m == nil {
44 | return "", ""
45 | }
46 | if m.Entities == nil || len(*m.Entities) == 0 {
47 | return "", ""
48 | }
49 | entity := (*m.Entities)[0]
50 | if entity.Offset > 0 || entity.Type != "bot_command" {
51 | return "", ""
52 | }
53 | cmdText := m.Text[0:entity.Length]
54 | usernameSuffix := "@" + bot.Self.UserName
55 | if strings.HasSuffix(cmdText, usernameSuffix) {
56 | return cmdText[:len(cmdText)-len(usernameSuffix)], strings.TrimSpace(m.Text[entity.Offset:])
57 | }
58 | return cmdText, strings.TrimSpace(m.Text[entity.Offset:])
59 | }
60 |
61 | func extractSubscriptorID(bot *tgbotapi.BotAPI, db *pg.DB, message *tgbotapi.Message) (int64, error) {
62 | from := message.From
63 | chat := message.Chat
64 |
65 | if chat.IsPrivate() {
66 | return int64(from.ID), nil
67 | } else if chat.IsGroup() || chat.IsSuperGroup() {
68 | admins, err := bot.GetChatAdministrators(chat.ChatConfig())
69 | if err != nil {
70 | return 0, merry.Wrap(err)
71 | }
72 | for _, admin := range admins {
73 | if admin.User.ID == from.ID {
74 | return chat.ID, nil
75 | }
76 | }
77 | return 0, ErrActionNotAllowed.Here()
78 | }
79 | return 0, merry.Errorf("unexpected chat type: %s in %#v", chat.Type, chat)
80 | }
81 |
82 | func sendAction(bot *tgbotapi.BotAPI, chatID int64, action string) error {
83 | v := url.Values{}
84 | v.Add("chat_id", strconv.FormatInt(chatID, 10))
85 | v.Add("action", action)
86 | _, err := bot.MakeRequest("sendChatAction", v)
87 | return merry.Wrap(err)
88 | }
89 |
90 | func subscripbe(db *pg.DB, id int64) error {
91 | log.Debug().Int64("id", id).Msg("subscribing")
92 | err := db.RunInTransaction(context.Background(), func(tx *pg.Tx) error {
93 | ids, err := core.AppConfigInt64Slice(tx, "tgbot:version_notif_ids", true)
94 | if err != nil {
95 | return merry.Wrap(err)
96 | }
97 | for _, curID := range ids {
98 | if curID == id {
99 | return nil
100 | }
101 | }
102 | return merry.Wrap(core.AppConfigSet(tx, "tgbot:version_notif_ids", append(ids, id)))
103 | })
104 | return merry.Wrap(err)
105 | }
106 |
107 | func unsubscripbe(db *pg.DB, id int64) error {
108 | log.Debug().Int64("id", id).Msg("unsubscribing")
109 | err := db.RunInTransaction(context.Background(), func(tx *pg.Tx) error {
110 | ids, err := core.AppConfigInt64Slice(tx, "tgbot:version_notif_ids", true)
111 | if err != nil {
112 | return merry.Wrap(err)
113 | }
114 | for i, curID := range ids {
115 | if curID == id {
116 | newIds := append(ids[0:i], ids[i+1:]...)
117 | return merry.Wrap(core.AppConfigSet(tx, "tgbot:version_notif_ids", newIds))
118 | }
119 | }
120 | return nil
121 | })
122 | return merry.Wrap(err)
123 | }
124 |
125 | func handleStart(bot *tgbotapi.BotAPI, db *pg.DB, update tgbotapi.Update, args string) error {
126 | return justSend(bot, update.Message.Chat.ID, "Привет.")
127 | }
128 |
129 | func handleVersions(bot *tgbotapi.BotAPI, db *pg.DB, update tgbotapi.Update, args string) error {
130 | sendAction(bot, update.Message.Chat.ID, "typing")
131 |
132 | text := ""
133 | for _, checker := range core.MakeCurVersionCheckers() {
134 | err := checker.FetchCurVersion()
135 | if err == nil {
136 | text += checker.MessageCur() + "\n"
137 | } else {
138 | text += checker.Key() + ": " + err.Error() + "\n"
139 | }
140 |
141 | }
142 | _, err := bot.Send(tgbotapi.MessageConfig{
143 | BaseChat: tgbotapi.BaseChat{
144 | ChatID: update.Message.Chat.ID,
145 | ReplyToMessageID: 0,
146 | },
147 | Text: text,
148 | DisableWebPagePreview: true,
149 | ParseMode: "Markdown",
150 | })
151 | return merry.Wrap(err)
152 | }
153 |
154 | func handleSubscribe(bot *tgbotapi.BotAPI, db *pg.DB, update tgbotapi.Update, args string) error {
155 | id, err := extractSubscriptorID(bot, db, update.Message)
156 | if merry.Is(err, ErrActionNotAllowed) {
157 | return merry.Wrap(justSend(bot, update.Message.Chat.ID, "У тебя здесь нет власти!\nДля включения персональных уведомлений пиши в ЛС."))
158 | }
159 | if err != nil {
160 | return merry.Wrap(err)
161 | }
162 | if err := subscripbe(db, id); err != nil {
163 | return merry.Wrap(err)
164 | }
165 | return merry.Wrap(justSend(bot, update.Message.Chat.ID, "Буду присылать сюда уведомления о версиях."))
166 | }
167 |
168 | func handleUnsubscribe(bot *tgbotapi.BotAPI, db *pg.DB, update tgbotapi.Update, args string) error {
169 | id, err := extractSubscriptorID(bot, db, update.Message)
170 | if merry.Is(err, ErrActionNotAllowed) {
171 | return merry.Wrap(justSend(bot, update.Message.Chat.ID, "У тебя здесь нет власти!"))
172 | }
173 | if err != nil {
174 | return merry.Wrap(err)
175 | }
176 | if err := unsubscripbe(db, id); err != nil {
177 | return merry.Wrap(err)
178 | }
179 | return merry.Wrap(justSend(bot, update.Message.Chat.ID, "Отключил уведомления о версиях."))
180 | }
181 |
182 | func StartTGBot(tgBotToken, socks5ProxyAddr string, webhook *WebhookConfig) error {
183 | db := utils.MakePGConnection()
184 |
185 | httpClient := &http.Client{}
186 | if socks5ProxyAddr != "" {
187 | // auth := &proxy.Auth{User: *socksUser, Password: *socksPassword}
188 | dialer, err := proxy.SOCKS5("tcp", socks5ProxyAddr, nil, proxy.Direct)
189 | if err != nil {
190 | return merry.Wrap(err)
191 | }
192 | httpTransport := &http.Transport{Dial: dialer.Dial}
193 | httpClient.Transport = httpTransport
194 | }
195 |
196 | bot, err := tgbotapi.NewBotAPIWithClient(tgBotToken, httpClient)
197 | if err != nil {
198 | return merry.Wrap(err)
199 | }
200 |
201 | log.Info().Str("username", bot.Self.UserName).Str("name", bot.Self.FirstName).Msg("authorized")
202 |
203 | var updates tgbotapi.UpdatesChannel
204 | if webhook != nil {
205 | log.Info().Msg("using webhook")
206 | _, err = bot.SetWebhook(tgbotapi.NewWebhook(webhook.URL))
207 | if err != nil {
208 | return merry.Wrap(err)
209 | }
210 | updates = bot.ListenForWebhook(webhook.ListenPath)
211 | go func() { log.Fatal().Err(http.ListenAndServe(webhook.ListenAddr, nil)) }()
212 | } else {
213 | log.Info().Msg("using polling")
214 | if _, err := bot.RemoveWebhook(); err != nil {
215 | return merry.Wrap(err)
216 | }
217 | u := tgbotapi.NewUpdate(0)
218 | u.Timeout = 60
219 | updates, err = bot.GetUpdatesChan(u)
220 | if err != nil {
221 | return merry.Wrap(err)
222 | }
223 | }
224 |
225 | handlers := map[string]cmdHandler{
226 | "/start": handleStart,
227 | "/versions": handleVersions,
228 | "/version": handleVersions,
229 | "/winver": handleVersions,
230 | "/subscribe": handleSubscribe,
231 | "/unsubscribe": handleUnsubscribe,
232 | }
233 |
234 | for update := range updates {
235 | // buf, _ := json.Marshal(update)
236 | // fmt.Println(">>> " + string(buf))
237 | cmd, args := extractCommand(bot, update)
238 | if handler, ok := handlers[cmd]; ok {
239 | if err := handler(bot, db, update, args); err != nil {
240 | return merry.Wrap(err)
241 | }
242 | } else if update.Message != nil && update.Message.Text != "" && !isReplyToBotInGroupChat(bot, update) {
243 | justSend(bot, update.Message.Chat.ID, "Не понял.")
244 | }
245 | }
246 | return nil
247 | }
248 |
--------------------------------------------------------------------------------
/core/ip_companies.go:
--------------------------------------------------------------------------------
1 | package core
2 |
3 | import (
4 | "encoding/json"
5 | "net"
6 | "net/http"
7 | "net/netip"
8 | "storjnet/utils"
9 | "strings"
10 | "time"
11 |
12 | "github.com/ansel1/merry"
13 | "github.com/go-pg/pg/v10"
14 | "github.com/rs/zerolog/log"
15 | )
16 |
17 | func UpdateIPCompanyIfNeed(db *pg.DB, ipAddr string) (bool, error) {
18 | var t int64
19 | _, err := db.Query(pg.Scan(&t), `
20 | SELECT 1 FROM network_companies
21 | WHERE ip_from <= ? AND ? <= ip_to
22 | AND incolumitas IS NOT NULL
23 | AND incolumitas_updated_at > NOW() - INTERVAL '7 days'
24 | LIMIT 1`,
25 | ipAddr, ipAddr)
26 | if t == 1 {
27 | return false, nil
28 | }
29 | if err != nil {
30 | return false, merry.Wrap(err)
31 | }
32 | _, err = db.Query(pg.Scan(&t), `
33 | SELECT 1 FROM network_company_unknown_ips
34 | WHERE ip_addr = ?
35 | AND updated_at > NOW() - INTERVAL '3 days'`,
36 | ipAddr, ipAddr)
37 | if t == 1 {
38 | return false, nil
39 | }
40 | if err != nil {
41 | return false, merry.Wrap(err)
42 | }
43 |
44 | company, found, err := fetchIPCompanyInfo(ipAddr)
45 | if err != nil {
46 | return false, merry.Wrap(err)
47 | }
48 | if !found {
49 | log.Warn().Str("ip", ipAddr).Msg("company not found, removing existing (if any)")
50 | res, err := db.Exec(`
51 | DELETE FROM network_companies WHERE ip_from <= ? AND ip_to >= ?`,
52 | ipAddr, ipAddr)
53 | if err != nil {
54 | return false, merry.Wrap(err)
55 | }
56 | log.Debug().Str("ip", ipAddr).Int("count", res.RowsAffected()).Msg("removed companies")
57 |
58 | _, err = db.Exec(`
59 | INSERT INTO network_company_unknown_ips (ip_addr) VALUES (?)
60 | ON CONFLICT (ip_addr) DO UPDATE SET updated_at = NOW()`,
61 | ipAddr)
62 | if err != nil {
63 | return false, merry.Wrap(err)
64 | }
65 | return false, nil
66 | }
67 |
68 | var intersections []struct {
69 | ID int64
70 | Network ipNetwork
71 | Incolumitas ipCompanyInfoToSave
72 | }
73 | _, err = db.Query(&intersections, `
74 | SELECT id, '"'||host(ip_from)||' - '||host(ip_to)||'"' AS network, incolumitas
75 | FROM network_companies WHERE ip_from <= ? AND ip_to >= ?`,
76 | company.Network.IPTo, company.Network.IPFrom)
77 | if err != nil {
78 | return false, merry.Wrap(err)
79 | }
80 |
81 | isAlreadySaved := false
82 | for _, isec := range intersections {
83 | // isec.range equals -> updating
84 | if isec.Network.IPFrom == company.Network.IPFrom && isec.Network.IPTo == company.Network.IPTo {
85 | if !isAlreadySaved {
86 | log.Debug().Any("net", company.Network).Str("name", company.Name).Msg("updating company")
87 | _, err := db.Exec(`
88 | UPDATE network_companies SET incolumitas = ?, incolumitas_updated_at = NOW() WHERE id = ?`,
89 | company.ipCompanyInfoToSave, isec.ID)
90 | isAlreadySaved = true
91 | if err != nil {
92 | return false, merry.Wrap(err)
93 | }
94 | } else {
95 | log.Debug().Any("net", company.Network).Any("old", isec.Network).Str("name", company.Name).Msg("removing existing double")
96 | _, err := db.Exec(`
97 | DELETE FROM network_companies WHERE id = ?`,
98 | isec.ID)
99 | if err != nil {
100 | return false, merry.Wrap(err)
101 | }
102 | }
103 | continue
104 | }
105 |
106 | // isec.range inside -> removing
107 | if company.Network.IPFrom.LE(isec.Network.IPFrom) && isec.Network.IPTo.LE(company.Network.IPTo) {
108 | if isec.Incolumitas.Equals(company.ipCompanyInfoToSave) {
109 | log.Debug().Any("net", company.Network).Any("old", isec.Network).Str("name", company.Name).Msg("removing existing inner")
110 | _, err := db.Exec(`
111 | DELETE FROM network_companies WHERE id = ?`,
112 | isec.ID)
113 | if err != nil {
114 | return false, merry.Wrap(err)
115 | }
116 | continue
117 | }
118 | }
119 |
120 | log.Warn().Any("old", isec).Any("new", company).Msg("companies intersection")
121 | }
122 |
123 | if !isAlreadySaved {
124 | log.Debug().Any("net", company.Network).Str("name", company.Name).Msg("inserting company")
125 | _, err := db.Exec(`
126 | INSERT INTO network_companies (ip_from, ip_to, incolumitas, incolumitas_updated_at)
127 | VALUES (?, ?, ?, NOW())`,
128 | company.Network.IPFrom, company.Network.IPTo, company.ipCompanyInfoToSave)
129 | if err != nil {
130 | return false, merry.Wrap(err)
131 | }
132 | }
133 | return true, nil
134 | }
135 |
136 | type ipNetwork struct {
137 | IPFrom utils.NetAddrPG `json:"ip_from"`
138 | IPTo utils.NetAddrPG `json:"ip_to"`
139 | }
140 |
141 | func (n ipNetwork) String() string {
142 | return n.IPFrom.String() + " - " + n.IPTo.String()
143 | }
144 |
145 | func (n ipNetwork) MarshalJSON() ([]byte, error) {
146 | return []byte(`"` + n.String() + `"`), nil
147 | }
148 |
149 | func (n *ipNetwork) UnmarshalJSON(data []byte) error {
150 | var str string
151 | if err := json.Unmarshal(data, &str); err != nil {
152 | return merry.Wrap(err)
153 | }
154 |
155 | sepIndex := strings.Index(str, "-")
156 | if sepIndex != -1 {
157 | ipFrom, err := netip.ParseAddr(strings.TrimSpace(str[:sepIndex]))
158 | if err != nil {
159 | return merry.Wrap(err)
160 | }
161 | ipTo, err := netip.ParseAddr(strings.TrimSpace(str[sepIndex+1:]))
162 | if err != nil {
163 | return merry.Wrap(err)
164 | }
165 |
166 | n.IPFrom.Addr = ipFrom
167 | n.IPTo.Addr = ipTo
168 | } else {
169 | prefix, err := netip.ParsePrefix(str)
170 | if err != nil {
171 | return merry.Wrap(err)
172 | }
173 |
174 | ipToArr := prefix.Addr().As16()
175 | prefixBits := 128 - prefix.Addr().BitLen() + prefix.Bits()
176 | for i := 15; i > prefixBits/8; i-- {
177 | ipToArr[i] = 0xFF
178 | }
179 | ipToArr[prefixBits/8] |= (^byte(0)) >> (prefixBits % 8)
180 | // fmt.Printf("%v (/%d) %08b %08b\n", ipToArr, prefix.Bits(), ipToArr[prefixBits/8], (^byte(0))>>(prefixBits%8))
181 |
182 | n.IPFrom.Addr = prefix.Masked().Addr()
183 | n.IPTo.Addr = netip.AddrFrom16(ipToArr).Unmap()
184 | }
185 |
186 | return nil
187 | }
188 |
189 | type ipCompanyInfoToSave struct {
190 | Name string `json:"name"` // "Supercom of California Limited",
191 | Domain string `json:"domain"` // "supercom.ca",
192 | Type string `json:"type"` // "business",
193 | }
194 |
195 | func (i ipCompanyInfoToSave) Equals(other ipCompanyInfoToSave) bool {
196 | return i.Name == other.Name && i.Domain == other.Domain && i.Type == other.Type
197 | }
198 |
199 | type ipCompanyInfo struct {
200 | ipCompanyInfoToSave
201 | Network ipNetwork `json:"network"` // "205.207.214.0 - 205.207.215.255",
202 | // AbuserScore string // "0 (Very Low)",
203 | // Whois string // "https://api.ipapi.is/?whois=205.207.214.0"
204 | }
205 |
206 | type ipInfoResponse struct {
207 | Company *ipCompanyInfo `json:"company"`
208 | Error string `json:"error"`
209 | Message string `json:"message"`
210 | }
211 |
212 | func fetchIPCompanyInfo(ipAddr string) (ipCompanyInfo, bool, error) {
213 | if net.ParseIP(ipAddr).IsPrivate() {
214 | return ipCompanyInfo{}, false, nil
215 | }
216 |
217 | // previously was api.incolumitas.com
218 | req, err := http.NewRequest("GET", "https://api.ipapi.is/?q="+ipAddr, nil)
219 | if err != nil {
220 | return ipCompanyInfo{}, false, merry.Wrap(err)
221 | }
222 | httpClient := http.Client{
223 | Timeout: 4 * time.Second, //got some timeouts after 3 seconds
224 | }
225 | // dialer, err := proxy.SOCKS5("tcp", "127.0.0.1:9051", nil, proxy.Direct)
226 | // if err != nil {
227 | // return ipCompanyInfo{}, false, merry.Wrap(err)
228 | // }
229 | // httpClient.Transport = &http.Transport{DialContext: dialer.(proxy.ContextDialer).DialContext}
230 |
231 | resp, err := httpClient.Do(req)
232 | if err != nil {
233 | return ipCompanyInfo{}, false, merry.Wrap(err)
234 | }
235 | defer resp.Body.Close()
236 |
237 | info := ipInfoResponse{}
238 | if err := json.NewDecoder(resp.Body).Decode(&info); err != nil {
239 | return ipCompanyInfo{}, false, merry.Wrap(err)
240 | }
241 | if info.Error != "" {
242 | var err merry.Error
243 | if strings.Contains(info.Message, "Too many API requests") {
244 | err = ErrIncolumitasTooManyRequests
245 | } else {
246 | err = merry.New("")
247 | }
248 | return ipCompanyInfo{}, false, err.Here().WithMessagef("IP %s: %s: %s", ipAddr, info.Error, info.Message)
249 | }
250 |
251 | name := "n/a"
252 | if info.Company != nil {
253 | name = info.Company.Name
254 | }
255 | log.Debug().Str("IP", ipAddr).Str("comp", name).Msg("fetched IP company from ipapi (ex incolumitas.com)")
256 |
257 | if info.Company == nil {
258 | return ipCompanyInfo{}, false, nil
259 | }
260 |
261 | return *info.Company, true, nil
262 | }
263 |
--------------------------------------------------------------------------------