Changeset 804 in code for trunk


Ignore:
Timestamp:
Mar 21, 2023, 4:45:19 AM (2 years ago)
Author:
koizumi.aoi
Message:

Drunk as I like

Signed-off-by: Aoi K <koizumi.aoi@…>

Location:
trunk
Files:
29 edited

Legend:

Unmodified
Added
Removed

  • trunk/Makefile

    r801 r804  
    77MANDIR ?= share/man
    88
    9 all: suika suikactl doc/suika.1
     9all: suika suikactl suika-znc-import doc/suika.1
    1010
    1111suika:

  • trunk/bridge.go

    r784 r804  
    1 package soju
     1package suika
    22
    33import (

  • trunk/certfp.go

    r614 r804  
    1 package soju
     1package suika
    22
    33import (
    … …  
    5858        cert := &x509.Certificate{
    5959                SerialNumber: serialNumber,
    60                 Subject:      pkix.Name{CommonName: "soju auto-generated certificate"},
     60                Subject:      pkix.Name{CommonName: "suika auto-generated certificate"},
    6161                NotBefore:    notBefore,
    6262                NotAfter:     notAfter,

  • trunk/cmd/suika-znc-import/main.go

    r801 r804  
    1717)
    1818
    19 const usage = `usage: soju-znc-import [options...] <znc config path>
     19const usage = `usage: suika-znc-import [options...] <znc config path>
    2020
    2121Imports configuration from a ZNC file. Users and networks are merged if they
    22 already exist in the soju database. ZNC settings overwrite existing soju
     22already exist in the suika database. ZNC settings overwrite existing suika
    2323settings.
    2424
    … …  
    2626
    2727  -help             Show this help message
    28   -config <path>    Path to soju config file
     28  -config <path>    Path to suika config file
    2929  -user <username>  Limit import to username (may be specified multiple times)
    3030  -network <name>   Limit import to network (may be specified multiple times)
    … …  
    6565        ctx := context.Background()
    6666
    67         db, err := soju.OpenDB(cfg.SQLDriver, cfg.SQLSource)
     67        db, err := suika.OpenDB(cfg.SQLDriver, cfg.SQLSource)
    6868        if err != nil {
    6969                log.Fatalf("failed to open database: %v", err)
    … …  
    8787                log.Fatalf("failed to list users in DB: %v", err)
    8888        }
    89         existingUsers := make(map[string]*soju.User, len(l))
     89        existingUsers := make(map[string]*suika.User, len(l))
    9090        for i, u := range l {
    9191                existingUsers[u.Username] = &l[i]
    … …  
    108108                } else {
    109109                        // "!!" is an invalid crypt format, thus disables password auth
    110                         u = &soju.User{Username: username, Password: "!!"}
     110                        u = &suika.User{Username: username, Password: "!!"}
    111111                        usersCreated++
    112112                        log.Printf("user %q: creating new user", username)
    … …  
    124124                        log.Fatalf("failed to list networks for user %q: %v", username, err)
    125125                }
    126                 existingNetworks := make(map[string]*soju.Network, len(l))
     126                existingNetworks := make(map[string]*suika.Network, len(l))
    127127                for i, n := range l {
    128128                        existingNetworks[n.GetName()] = &l[i]
    … …  
    176176                                logger.Printf("updating existing network")
    177177                        } else {
    178                                 n = &soju.Network{Name: netName}
     178                                n = &suika.Network{Name: netName}
    179179                                logger.Printf("creating new network")
    180180                        }
    … …  
    195195                                logger.Fatalf("failed to list channels: %v", err)
    196196                        }
    197                         existingChannels := make(map[string]*soju.Channel, len(l))
     197                        existingChannels := make(map[string]*suika.Channel, len(l))
    198198                        for i, ch := range l {
    199199                                existingChannels[ch.Name] = &l[i]
    … …  
    214214                                        logger.Printf("channel %q: updating existing channel", chName)
    215215                                } else {
    216                                         ch = &soju.Channel{Name: chName}
     216                                        ch = &suika.Channel{Name: chName}
    217217                                        logger.Printf("channel %q: creating new channel", chName)
    218218                                }
    … …  
    233233
    234234        if usersCreated > 0 {
    235                 log.Printf("warning: user passwords haven't been imported, please set them with `sojuctl change-password <username>`")
     235                log.Printf("warning: user passwords haven't been imported, please set them with `suikactl change-password <username>`")
    236236        }
    237237

  • trunk/cmd/suika/main.go

    r801 r804  
    6060)
    6161
    62 func loadConfig() (*config.Server, *soju.Config, error) {
     62func loadConfig() (*config.Server, *suika.Config, error) {
    6363        var raw *config.Server
    6464        if configPath != "" {
    … …  
    8989        }
    9090
    91         cfg := &soju.Config{
     91        cfg := &suika.Config{
    9292                Hostname:        raw.Hostname,
    9393                Title:           raw.Title,
    … …  
    124124        }
    125125
    126         db, err := soju.OpenDB(cfg.SQLDriver, cfg.SQLSource)
     126        db, err := suika.OpenDB(cfg.SQLDriver, cfg.SQLSource)
    127127        if err != nil {
    128128                log.Fatalf("failed to open database: %v", err)
    … …  
    138138        }
    139139
    140         srv := soju.NewServer(db)
     140        srv := suika.NewServer(db)
    141141        srv.SetConfig(serverCfg)
    142         srv.Logger = soju.NewLogger(log.Writer(), debug)
     142        srv.Logger = suika.NewLogger(log.Writer(), debug)
    143143
    144144        for _, listen := range cfg.Listen {
    … …  
    242242                case "ident":
    243243                        if srv.Identd == nil {
    244                                 srv.Identd = soju.NewIdentd()
     244                                srv.Identd = suika.NewIdentd()
    245245                        }
    246246
    … …  
    316316        }
    317317
    318         if db, ok := db.(soju.MetricsCollectorDatabase); ok && srv.MetricsRegistry != nil {
     318        if db, ok := db.(suika.MetricsCollectorDatabase); ok && srv.MetricsRegistry != nil {
    319319                srv.MetricsRegistry.MustRegister(db.MetricsCollector())
    320320        }
    … …  
    345345}
    346346
    347 func proxyProtoListener(ln net.Listener, srv *soju.Server) net.Listener {
     347func proxyProtoListener(ln net.Listener, srv *suika.Server) net.Listener {
    348348        return &proxyproto.Listener{
    349349                Listener: ln,

  • trunk/cmd/suikactl/main.go

    r801 r804  
    1616)
    1717
    18 const usage = `usage: sojuctl [-config path] <action> [options...]
     18const usage = `usage: suikactl [-config path] <action> [options...]
    1919
    2020  create-user <username> [-admin]  Create a new user
    … …  
    4545        }
    4646
    47         db, err := soju.OpenDB(cfg.SQLDriver, cfg.SQLSource)
     47        db, err := suika.OpenDB(cfg.SQLDriver, cfg.SQLSource)
    4848        if err != nil {
    4949                log.Fatalf("failed to open database: %v", err)
    … …  
    7474                }
    7575
    76                 user := soju.User{
     76                user := suika.User{
    7777                        Username: username,
    7878                        Password: string(hashed),

  • trunk/config/config.go

    r705 r804  
    6464                Hostname:        hostname,
    6565                SQLDriver:       "sqlite3",
    66                 SQLSource:       "soju.db",
     66                SQLSource:       "suika.db",
    6767                MaxUserNetworks: -1,
    6868                MultiUpstream:   true,

  • trunk/conn.go

    r757 r804  
    1 package soju
     1package suika
    22
    33import (

  • trunk/db.go

    r781 r804  
    1 package soju
     1package suika
    22
    33import (

  • trunk/db_postgres.go

    r781 r804  
    1 package soju
     1package suika
    22
    33import (
    … …  
    149149        }
    150150        if version > len(postgresMigrations) {
    151                 return fmt.Errorf("soju (version %d) older than schema (version %d)", len(postgresMigrations), version)
     151                return fmt.Errorf("suika (version %d) older than schema (version %d)", len(postgresMigrations), version)
    152152        }
    153153
    … …  
    344344                        // keep saslPlain* nil
    345345                default:
    346                         return fmt.Errorf("soju: cannot store network: unsupported SASL mechanism %q", network.SASL.Mechanism)
     346                        return fmt.Errorf("suika: cannot store network: unsupported SASL mechanism %q", network.SASL.Mechanism)
    347347                }
    348348        }

  • trunk/db_postgres_test.go

    r621 r804  
    1 package soju
     1package suika
    22
    33import (

  • trunk/db_sqlite.go

    r784 r804  
    1 package soju
     1package suika
    22
    33import (
    … …  
    230230                return nil
    231231        } else if version > len(sqliteMigrations) {
    232                 return fmt.Errorf("soju (version %d) older than schema (version %d)", len(sqliteMigrations), version)
     232                return fmt.Errorf("suika (version %d) older than schema (version %d)", len(sqliteMigrations), version)
    233233        }
    234234
    … …  
    507507                        // keep saslPlain* nil
    508508                default:
    509                         return fmt.Errorf("soju: cannot store network: unsupported SASL mechanism %q", network.SASL.Mechanism)
     509                        return fmt.Errorf("suika: cannot store network: unsupported SASL mechanism %q", network.SASL.Mechanism)
    510510                }
    511511        }

  • trunk/db_sqlite_test.go

    r619 r804  
    1 package soju
     1package suika
    22
    33import (

  • trunk/downstream.go

    r794 r804  
    1 package soju
     1package suika
    22
    33import (
    … …  
    410410        if dc.network != nil {
    411411                if dc.network != net {
    412                         panic("soju: tried to marshal an entity for another network")
     412                        panic("suika: tried to marshal an entity for another network")
    413413                }
    414414                return name
    … …  
    424424        if dc.network != nil {
    425425                if dc.network != net {
    426                         panic("soju: tried to marshal a user prefix for another network")
     426                        panic("suika: tried to marshal a user prefix for another network")
    427427                }
    428428                return prefix
    … …  
    632632
    633633func (dc *downstreamConn) sendPing(msgID string) {
    634         token := "soju-msgid-" + msgID
     634        token := "suika-msgid-" + msgID
    635635        dc.SendMessage(&irc.Message{
    636636                Command: "PING",
    … …  
    640640
    641641func (dc *downstreamConn) handlePong(token string) {
    642         if !strings.HasPrefix(token, "soju-msgid-") {
     642        if !strings.HasPrefix(token, "suika-msgid-") {
    643643                dc.logger.Printf("received unrecognized PONG token %q", token)
    644644                return
    645645        }
    646         msgID := strings.TrimPrefix(token, "soju-msgid-")
     646        msgID := strings.TrimPrefix(token, "suika-msgid-")
    647647        dc.ackMsgID(msgID)
    648648}
    … …  
    14121412                Prefix:  dc.srv.prefix(),
    14131413                Command: irc.RPL_WELCOME,
    1414                 Params:  []string{dc.nick, "Welcome to soju, " + dc.nick},
     1414                Params:  []string{dc.nick, "Welcome to suika, " + dc.nick},
    14151415        })
    14161416        dc.SendMessage(&irc.Message{
    … …  
    14221422                Prefix:  dc.srv.prefix(),
    14231423                Command: irc.RPL_MYINFO,
    1424                 Params:  []string{dc.nick, dc.srv.Config().Hostname, "soju", "aiwroO", "OovaimnqpsrtklbeI"},
     1424                Params:  []string{dc.nick, dc.srv.Config().Hostname, "suika", "aiwroO", "OovaimnqpsrtklbeI"},
    14251425        })
    14261426        for _, msg := range generateIsupport(dc.srv.prefix(), dc.nick, isupport) {
    … …  
    22582258                                Prefix:  dc.srv.prefix(),
    22592259                                Command: irc.RPL_WHOISSERVER,
    2260                                 Params:  []string{dc.nick, dc.nick, dc.srv.Config().Hostname, "soju"},
     2260                                Params:  []string{dc.nick, dc.nick, dc.srv.Config().Hostname, "suika"},
    22612261                        })
    22622262                        if dc.user.Admin {
    … …  
    22882288                                Prefix:  dc.srv.prefix(),
    22892289                                Command: irc.RPL_WHOISSERVER,
    2290                                 Params:  []string{dc.nick, serviceNick, dc.srv.Config().Hostname, "soju"},
     2290                                Params:  []string{dc.nick, serviceNick, dc.srv.Config().Hostname, "suika"},
    22912291                        })
    22922292                        dc.SendMessage(&irc.Message{

  • trunk/ident.go

    r766 r804  
    1 package soju
     1package suika
    22
    33import (

  • trunk/irc.go

    r786 r804  
    1 package soju
     1package suika
    22
    33import (

  • trunk/irc_test.go

    r785 r804  
    1 package soju
     1package suika
    22
    33import (

  • trunk/msgstore.go

    r667 r804  
    1 package soju
     1package suika
    22
    33import (

  • trunk/msgstore_fs.go

    r787 r804  
    1 package soju
     1package suika
    22
    33import (

  • trunk/msgstore_memory.go

    r669 r804  
    1 package soju
     1package suika
    22
    33import (

  • trunk/net_go113.go

    r582 r804  
    22// +build !go1.16
    33
    4 package soju
     4package suika
    55
    66import (

  • trunk/net_go116.go

    r582 r804  
    22// +build go1.16
    33
    4 package soju
     4package suika
    55
    66import (

  • trunk/rate.go

    r735 r804  
    1 package soju
     1package suika
    22
    33import (

  • trunk/server.go

    r801 r804  
    1 package soju
     1package suika
    22
    33import (
    … …  
    210210
    211211        factory.NewGaugeFunc(prometheus.GaugeOpts{
    212                 Name: "soju_users_active",
     212                Name: "suika_users_active",
    213213                Help: "Current number of active users",
    214214        }, func() float64 {
    … …  
    220220
    221221        factory.NewGaugeFunc(prometheus.GaugeOpts{
    222                 Name: "soju_downstreams_active",
     222                Name: "suika_downstreams_active",
    223223                Help: "Current number of downstream connections",
    224224        }, s.metrics.downstreams.Float64)
    225225
    226226        factory.NewGaugeFunc(prometheus.GaugeOpts{
    227                 Name: "soju_upstreams_active",
     227                Name: "suika_upstreams_active",
    228228                Help: "Current number of upstream connections",
    229229        }, s.metrics.upstreams.Float64)
    230230
    231231        s.metrics.upstreamOutMessagesTotal = factory.NewCounter(prometheus.CounterOpts{
    232                 Name: "soju_upstream_out_messages_total",
     232                Name: "suika_upstream_out_messages_total",
    233233                Help: "Total number of outgoing messages sent to upstream servers",
    234234        })
    235235
    236236        s.metrics.upstreamInMessagesTotal = factory.NewCounter(prometheus.CounterOpts{
    237                 Name: "soju_upstream_in_messages_total",
     237                Name: "suika_upstream_in_messages_total",
    238238                Help: "Total number of incoming messages received from upstream servers",
    239239        })
    240240
    241241        s.metrics.downstreamOutMessagesTotal = factory.NewCounter(prometheus.CounterOpts{
    242                 Name: "soju_downstream_out_messages_total",
     242                Name: "suika_downstream_out_messages_total",
    243243                Help: "Total number of outgoing messages sent to downstream clients",
    244244        })
    245245
    246246        s.metrics.downstreamInMessagesTotal = factory.NewCounter(prometheus.CounterOpts{
    247                 Name: "soju_downstream_in_messages_total",
     247                Name: "suika_downstream_in_messages_total",
    248248                Help: "Total number of incoming messages received from downstream clients",
    249249        })
    250250
    251251        s.metrics.upstreamConnectErrorsTotal = factory.NewCounter(prometheus.CounterOpts{
    252                 Name: "soju_upstream_connect_errors_total",
     252                Name: "suika_upstream_connect_errors_total",
    253253                Help: "Total number of upstream connection errors",
    254254        })

  • trunk/server_test.go

    r697 r804  
    1 package soju
     1package suika
    22
    33import (
    … …  
    1010)
    1111
    12 var testServerPrefix = &irc.Prefix{Name: "soju-test-server"}
     12var testServerPrefix = &irc.Prefix{Name: "suika-test-server"}
    1313
    1414const (
    15         testUsername = "soju-test-user"
     15        testUsername = "suika-test-user"
    1616        testPassword = testUsername
    1717)
    … …  
    133133                Prefix:  testServerPrefix,
    134134                Command: irc.RPL_YOURHOST,
    135                 Params:  []string{nick, "Your host is soju-test-server"},
     135                Params:  []string{nick, "Your host is suika-test-server"},
    136136        })
    137137        c.WriteMessage(&irc.Message{
    … …  
    143143                Prefix:  testServerPrefix,
    144144                Command: irc.RPL_MYINFO,
    145                 Params:  []string{nick, testServerPrefix.Name, "soju", "aiwroO", "OovaimnqpsrtklbeI"},
     145                Params:  []string{nick, testServerPrefix.Name, "suika", "aiwroO", "OovaimnqpsrtklbeI"},
    146146        })
    147147        c.WriteMessage(&irc.Message{

  • trunk/service.go

    r772 r804  
    1 package soju
     1package suika
    22
    33import (
    … …  
    2222const serviceNick = "BouncerServ"
    2323const serviceNickCM = "bouncerserv"
    24 const serviceRealname = "soju bouncer service"
     24const serviceRealname = "suika bouncer service"
    2525
    2626// maxRSABits is the maximum number of RSA key bits used when generating a new
    … …  
    262262                                "create": {
    263263                                        usage:  "-username <username> -password <password> [-realname <realname>] [-admin]",
    264                                         desc:   "create a new soju user",
     264                                        desc:   "create a new suika user",
    265265                                        handle: handleUserCreate,
    266266                                        admin:  true,

  • trunk/service_test.go

    r566 r804  
    1 package soju
     1package suika
    22
    33import (
    … …  
    2323
    2424func TestSplit(t *testing.T) {
    25         assertSplit(t, "  ch 'up' #soju    'relay'-det\"ache\"d  message  ", []string{
     25        assertSplit(t, "  ch 'up' #suika    'relay'-det\"ache\"d  message  ", []string{
    2626                "ch",
    2727                "up",
    28                 "#soju",
     28                "#suika",
    2929                "relay-detached",
    3030                "message",

  • trunk/upstream.go

    r784 r804  
    1 package soju
     1package suika
    22
    33import (
    … …  
    200200
    201201                // Don't do the TLS handshake immediately, because we need to register
    202                 // the new connection with identd ASAP. See:
    203                 // https://todo.sr.ht/~emersion/soju/69#event-41859
     202                // the new connection with identd ASAP.
    204203                netConn = tls.Client(netConn, tlsConfig)
    205204        case "irc+insecure":
    … …  
    473472
    474473                if msg.Prefix.Name == serviceNick {
    475                         uc.logger.Printf("skipping %v from soju's service: %v", msg.Command, msg)
     474                        uc.logger.Printf("skipping %v from suika's service: %v", msg.Command, msg)
    476475                        break
    477476                }
    478477                if entity == serviceNick {
    479                         uc.logger.Printf("skipping %v to soju's service: %v", msg.Command, msg)
     478                        uc.logger.Printf("skipping %v to suika's service: %v", msg.Command, msg)
    480479                        break
    481480                }

  • trunk/user.go

    r787 r804  
    1 package soju
     1package suika
    22
    33import (
Note: See TracChangeset for help on using the changeset viewer.