getwtxt/getwtxt

/*
Copyright (c) 2019 Ben Morrison (gbmor)

This file is part of Registry.

Registry is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Registry is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Registry.  If not, see <https://www.gnu.org/licenses/>.
*/

package registry // import "git.sr.ht/~gbmor/getwtxt/registry"

import (
    "fmt"
    "net"
    "strings"
    "sync"
    "time"
)

// AddUser inserts a new user into the Registry.
func (registry *Registry) AddUser(nickname, urlKey string, ipAddress net.IP, statuses TimeMap) error {

    if registry == nil {
        return fmt.Errorf("can't add user to uninitialized registry")

    } else if nickname == "" || urlKey == "" {
        return fmt.Errorf("both URL and Nick must be specified")

    } else if !strings.HasPrefix(urlKey, "http") {
        return fmt.Errorf("invalid URL: %v", urlKey)
    }

    registry.Mu.Lock()
    defer registry.Mu.Unlock()

    if _, ok := registry.Users[urlKey]; ok {
        return fmt.Errorf("user %v already exists", urlKey)
    }

    registry.Users[urlKey] = &User{
        Mu:           sync.RWMutex{},
        Nick:         nickname,
        URL:          urlKey,
        LastModified: "",
        IP:           ipAddress,
        Date:         time.Now().Format(time.RFC3339),
        Status:       statuses}

    return nil
}

// Put inserts a given User into an Registry. The User
// being pushed need only have the URL field filled.
// All other fields may be empty.
// This can be destructive: an existing User in the
// Registry will be overwritten if its User.URL is the
// same as the User.URL being pushed.
func (registry *Registry) Put(user *User) error {
    if user == nil {
        return fmt.Errorf("can't push nil data to registry")
    }
    if registry == nil || registry.Users == nil {
        return fmt.Errorf("can't push data to registry: registry uninitialized")
    }
    user.Mu.RLock()
    if user.URL == "" {
        user.Mu.RUnlock()
        return fmt.Errorf("can't push data to registry: missing URL for key")
    }
    urlKey := user.URL
    registry.Mu.Lock()
    registry.Users[urlKey] = user
    registry.Mu.Unlock()
    user.Mu.RUnlock()

    return nil
}

// Get returns the User associated with the
// provided URL key in the Registry.
func (registry *Registry) Get(urlKey string) (*User, error) {
    if registry == nil {
        return nil, fmt.Errorf("can't pop from nil registry")
    }
    if urlKey == "" {
        return nil, fmt.Errorf("can't pop unless provided a key")
    }

    registry.Mu.RLock()
    defer registry.Mu.RUnlock()

    if _, ok := registry.Users[urlKey]; !ok {
        return nil, fmt.Errorf("provided url key doesn't exist in registry")
    }

    registry.Users[urlKey].Mu.RLock()
    userGot := registry.Users[urlKey]
    registry.Users[urlKey].Mu.RUnlock()

    return userGot, nil
}

// DelUser removes a user and all associated data from
// the Registry.
func (registry *Registry) DelUser(urlKey string) error {

    if registry == nil {
        return fmt.Errorf("can't delete user from empty registry")

    } else if urlKey == "" {
        return fmt.Errorf("can't delete blank user")

    } else if !strings.HasPrefix(urlKey, "http") {
        return fmt.Errorf("invalid URL: %v", urlKey)
    }

    registry.Mu.Lock()
    defer registry.Mu.Unlock()

    if _, ok := registry.Users[urlKey]; !ok {
        return fmt.Errorf("can't delete user %v, user doesn't exist", urlKey)
    }

    delete(registry.Users, urlKey)

    return nil
}

// UpdateUser scrapes an existing user's remote twtxt.txt
// file. Any new statuses are added to the user's entry
// in the Registry. If the remote twtxt data's reported
// Content-Length does not differ from what is stored,
// an error is returned.
func (registry *Registry) UpdateUser(urlKey string) error {
    if urlKey == "" || !strings.HasPrefix(urlKey, "http") {
        return fmt.Errorf("invalid URL: %v", urlKey)
    }

    diff, err := registry.DiffTwtxt(urlKey)
    if err != nil {
        return err
    } else if !diff {
        return fmt.Errorf("no new statuses available for %v", urlKey)
    }

    out, isRemoteRegistry, err := GetTwtxt(urlKey, registry.HTTPClient)
    if err != nil {
        return err
    }

    if isRemoteRegistry {
        return fmt.Errorf("attempting to update registry URL - users should be updated individually")
    }

    registry.Mu.Lock()
    defer registry.Mu.Unlock()
    user := registry.Users[urlKey]

    user.Mu.Lock()
    defer user.Mu.Unlock()
    nick := user.Nick

    data, err := ParseUserTwtxt(out, nick, urlKey)
    if err != nil {
        return err
    }

    for i, e := range data {
        user.Status[i] = e
    }

    registry.Users[urlKey] = user

    return nil
}

// CrawlRemoteRegistry scrapes all nicknames and user URLs
// from a provided registry. The urlKey passed to this function
// must be in the form of https://registry.example.com/api/plain/users
func (registry *Registry) CrawlRemoteRegistry(urlKey string) error {
    if urlKey == "" || !strings.HasPrefix(urlKey, "http") {
        return fmt.Errorf("invalid URL: %v", urlKey)
    }

    out, isRemoteRegistry, err := GetTwtxt(urlKey, registry.HTTPClient)
    if err != nil {
        return err
    }

    if !isRemoteRegistry {
        return fmt.Errorf("can't add single user via call to CrawlRemoteRegistry")
    }

    users, err := ParseRegistryTwtxt(out)
    if err != nil {
        return err
    }

    // only add new users so we don't overwrite data
    // we already have (and lose statuses, etc)
    registry.Mu.Lock()
    defer registry.Mu.Unlock()
    for _, e := range users {
        if _, ok := registry.Users[e.URL]; !ok {
            registry.Users[e.URL] = e
        }
    }

    return nil
}

// GetUserStatuses returns a TimeMap containing single user's statuses
func (registry *Registry) GetUserStatuses(urlKey string) (TimeMap, error) {
    if registry == nil {
        return nil, fmt.Errorf("can't get statuses from an empty registry")
    } else if urlKey == "" || !strings.HasPrefix(urlKey, "http") {
        return nil, fmt.Errorf("invalid URL: %v", urlKey)
    }

    registry.Mu.RLock()
    defer registry.Mu.RUnlock()
    if _, ok := registry.Users[urlKey]; !ok {
        return nil, fmt.Errorf("can't retrieve statuses of nonexistent user")
    }

    registry.Users[urlKey].Mu.RLock()
    status := registry.Users[urlKey].Status
    registry.Users[urlKey].Mu.RUnlock()

    return status, nil
}

// GetStatuses returns a TimeMap containing all statuses
// from all users in the Registry.
func (registry *Registry) GetStatuses() (TimeMap, error) {
    if registry == nil {
        return nil, fmt.Errorf("can't get statuses from an empty registry")
    }

    statuses := NewTimeMap()

    registry.Mu.RLock()
    defer registry.Mu.RUnlock()

    for _, v := range registry.Users {
        v.Mu.RLock()
        if v.Status == nil || len(v.Status) == 0 {
            v.Mu.RUnlock()
            continue
        }
        for a, b := range v.Status {
            if _, ok := v.Status[a]; ok {
                statuses[a] = b
            }
        }
        v.Mu.RUnlock()
    }

    return statuses, nil
}