mirror of https://github.com/fiatjaf/nak.git
365 lines
9.2 KiB
Go
365 lines
9.2 KiB
Go
package nostrfs
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"syscall"
|
|
"time"
|
|
"unsafe"
|
|
|
|
"fiatjaf.com/lib/debouncer"
|
|
"github.com/fatih/color"
|
|
"github.com/hanwen/go-fuse/v2/fs"
|
|
"github.com/hanwen/go-fuse/v2/fuse"
|
|
"github.com/nbd-wtf/go-nostr"
|
|
"github.com/nbd-wtf/go-nostr/nip19"
|
|
"github.com/nbd-wtf/go-nostr/nip27"
|
|
"github.com/nbd-wtf/go-nostr/nip92"
|
|
sdk "github.com/nbd-wtf/go-nostr/sdk"
|
|
)
|
|
|
|
type EntityDir struct {
|
|
fs.Inode
|
|
root *NostrRoot
|
|
|
|
publisher *debouncer.Debouncer
|
|
extension string
|
|
event *nostr.Event
|
|
updating struct {
|
|
title string
|
|
content string
|
|
}
|
|
}
|
|
|
|
var (
|
|
_ = (fs.NodeOnAdder)((*EntityDir)(nil))
|
|
_ = (fs.NodeGetattrer)((*EntityDir)(nil))
|
|
_ = (fs.NodeCreater)((*EntityDir)(nil))
|
|
_ = (fs.NodeUnlinker)((*EntityDir)(nil))
|
|
)
|
|
|
|
func (e *EntityDir) Getattr(_ context.Context, f fs.FileHandle, out *fuse.AttrOut) syscall.Errno {
|
|
publishedAt := uint64(e.event.CreatedAt)
|
|
out.Ctime = publishedAt
|
|
|
|
if tag := e.event.Tags.Find("published_at"); tag != nil {
|
|
publishedAt, _ = strconv.ParseUint(tag[1], 10, 64)
|
|
}
|
|
out.Mtime = publishedAt
|
|
|
|
return fs.OK
|
|
}
|
|
|
|
func (e *EntityDir) Create(
|
|
_ context.Context,
|
|
name string,
|
|
flags uint32,
|
|
mode uint32,
|
|
out *fuse.EntryOut,
|
|
) (node *fs.Inode, fh fs.FileHandle, fuseFlags uint32, errno syscall.Errno) {
|
|
if name == "publish" {
|
|
// this causes the publish process to be triggered faster
|
|
e.publisher.Flush()
|
|
return nil, nil, 0, syscall.ENOTDIR
|
|
}
|
|
|
|
return nil, nil, 0, syscall.ENOTSUP
|
|
}
|
|
|
|
func (e *EntityDir) Unlink(ctx context.Context, name string) syscall.Errno {
|
|
switch name {
|
|
case "content" + e.extension:
|
|
e.updating.content = e.event.Content
|
|
return syscall.ENOTDIR
|
|
case "title":
|
|
e.updating.title = ""
|
|
if titleTag := e.event.Tags.Find("title"); titleTag != nil {
|
|
e.updating.title = titleTag[1]
|
|
}
|
|
return syscall.ENOTDIR
|
|
default:
|
|
return syscall.EINTR
|
|
}
|
|
}
|
|
|
|
func (e *EntityDir) OnAdd(_ context.Context) {
|
|
log := e.root.ctx.Value("log").(func(msg string, args ...any))
|
|
publishedAt := uint64(e.event.CreatedAt)
|
|
if tag := e.event.Tags.Find("published_at"); tag != nil {
|
|
publishedAt, _ = strconv.ParseUint(tag[1], 10, 64)
|
|
}
|
|
|
|
npub, _ := nip19.EncodePublicKey(e.event.PubKey)
|
|
e.AddChild("@author", e.NewPersistentInode(
|
|
e.root.ctx,
|
|
&fs.MemSymlink{
|
|
Data: []byte(e.root.wd + "/" + npub),
|
|
},
|
|
fs.StableAttr{Mode: syscall.S_IFLNK},
|
|
), true)
|
|
|
|
e.AddChild("event.json", e.NewPersistentInode(
|
|
e.root.ctx,
|
|
&DeterministicFile{
|
|
get: func() (ctime uint64, mtime uint64, data string) {
|
|
eventj, _ := json.MarshalIndent(e.event, "", " ")
|
|
return uint64(e.event.CreatedAt),
|
|
uint64(e.event.CreatedAt),
|
|
unsafe.String(unsafe.SliceData(eventj), len(eventj))
|
|
},
|
|
},
|
|
fs.StableAttr{},
|
|
), true)
|
|
|
|
e.AddChild("identifier", e.NewPersistentInode(
|
|
e.root.ctx,
|
|
&fs.MemRegularFile{
|
|
Data: []byte(e.event.Tags.GetD()),
|
|
Attr: fuse.Attr{
|
|
Mode: 0444,
|
|
Ctime: uint64(e.event.CreatedAt),
|
|
Mtime: uint64(e.event.CreatedAt),
|
|
Size: uint64(len(e.event.Tags.GetD())),
|
|
},
|
|
},
|
|
fs.StableAttr{},
|
|
), true)
|
|
|
|
if e.root.signer == nil {
|
|
// read-only
|
|
e.AddChild("title", e.NewPersistentInode(
|
|
e.root.ctx,
|
|
&DeterministicFile{
|
|
get: func() (ctime uint64, mtime uint64, data string) {
|
|
var title string
|
|
if tag := e.event.Tags.Find("title"); tag != nil {
|
|
title = tag[1]
|
|
} else {
|
|
title = e.event.Tags.GetD()
|
|
}
|
|
return uint64(e.event.CreatedAt), publishedAt, title
|
|
},
|
|
},
|
|
fs.StableAttr{},
|
|
), true)
|
|
e.AddChild("content."+e.extension, e.NewPersistentInode(
|
|
e.root.ctx,
|
|
&DeterministicFile{
|
|
get: func() (ctime uint64, mtime uint64, data string) {
|
|
return uint64(e.event.CreatedAt), publishedAt, e.event.Content
|
|
},
|
|
},
|
|
fs.StableAttr{},
|
|
), true)
|
|
} else {
|
|
// writeable
|
|
if tag := e.event.Tags.Find("title"); tag != nil {
|
|
e.updating.title = tag[1]
|
|
}
|
|
e.updating.content = e.event.Content
|
|
|
|
e.AddChild("title", e.NewPersistentInode(
|
|
e.root.ctx,
|
|
e.root.NewWriteableFile(e.updating.title, uint64(e.event.CreatedAt), publishedAt, func(s string) {
|
|
log("title updated")
|
|
e.updating.title = strings.TrimSpace(s)
|
|
e.handleWrite()
|
|
}),
|
|
fs.StableAttr{},
|
|
), true)
|
|
|
|
e.AddChild("content."+e.extension, e.NewPersistentInode(
|
|
e.root.ctx,
|
|
e.root.NewWriteableFile(e.updating.content, uint64(e.event.CreatedAt), publishedAt, func(s string) {
|
|
log("content updated")
|
|
e.updating.content = strings.TrimSpace(s)
|
|
e.handleWrite()
|
|
}),
|
|
fs.StableAttr{},
|
|
), true)
|
|
}
|
|
|
|
var refsdir *fs.Inode
|
|
i := 0
|
|
for ref := range nip27.ParseReferences(*e.event) {
|
|
i++
|
|
if refsdir == nil {
|
|
refsdir = e.NewPersistentInode(e.root.ctx, &fs.Inode{}, fs.StableAttr{Mode: syscall.S_IFDIR})
|
|
e.root.AddChild("references", refsdir, true)
|
|
}
|
|
refsdir.AddChild(fmt.Sprintf("ref_%02d", i), refsdir.NewPersistentInode(
|
|
e.root.ctx,
|
|
&fs.MemSymlink{
|
|
Data: []byte(e.root.wd + "/" + nip19.EncodePointer(ref.Pointer)),
|
|
},
|
|
fs.StableAttr{Mode: syscall.S_IFLNK},
|
|
), true)
|
|
}
|
|
|
|
var imagesdir *fs.Inode
|
|
addImage := func(url string) {
|
|
if imagesdir == nil {
|
|
in := &fs.Inode{}
|
|
imagesdir = e.NewPersistentInode(e.root.ctx, in, fs.StableAttr{Mode: syscall.S_IFDIR})
|
|
e.AddChild("images", imagesdir, true)
|
|
}
|
|
imagesdir.AddChild(filepath.Base(url), imagesdir.NewPersistentInode(
|
|
e.root.ctx,
|
|
&AsyncFile{
|
|
ctx: e.root.ctx,
|
|
load: func() ([]byte, nostr.Timestamp) {
|
|
ctx, cancel := context.WithTimeout(e.root.ctx, time.Second*20)
|
|
defer cancel()
|
|
r, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
log("failed to load image %s: %s\n", url, err)
|
|
return nil, 0
|
|
}
|
|
resp, err := http.DefaultClient.Do(r)
|
|
if err != nil {
|
|
log("failed to load image %s: %s\n", url, err)
|
|
return nil, 0
|
|
}
|
|
defer resp.Body.Close()
|
|
if resp.StatusCode >= 300 {
|
|
log("failed to load image %s: %s\n", url, err)
|
|
return nil, 0
|
|
}
|
|
w := &bytes.Buffer{}
|
|
io.Copy(w, resp.Body)
|
|
return w.Bytes(), 0
|
|
},
|
|
},
|
|
fs.StableAttr{},
|
|
), true)
|
|
}
|
|
|
|
images := nip92.ParseTags(e.event.Tags)
|
|
for _, imeta := range images {
|
|
if imeta.URL == "" {
|
|
continue
|
|
}
|
|
addImage(imeta.URL)
|
|
}
|
|
|
|
if tag := e.event.Tags.Find("image"); tag != nil {
|
|
addImage(tag[1])
|
|
}
|
|
}
|
|
|
|
func (e *EntityDir) handleWrite() {
|
|
log := e.root.ctx.Value("log").(func(msg string, args ...any))
|
|
|
|
if e.publisher.IsRunning() {
|
|
log(", timer reset")
|
|
}
|
|
log(", will publish the updated event in 30 seconds...\n")
|
|
if !e.publisher.IsRunning() {
|
|
log("- `touch publish` to publish immediately\n")
|
|
log("- `rm title content." + e.extension + "` to erase and cancel the edits\n")
|
|
}
|
|
|
|
e.publisher.Call(func() {
|
|
if currentTitle := e.event.Tags.Find("title"); (currentTitle != nil && currentTitle[1] == e.updating.title) || (currentTitle == nil && e.updating.title == "") && e.updating.content == e.event.Content {
|
|
log("back into the previous state, not publishing.\n")
|
|
return
|
|
}
|
|
|
|
evt := nostr.Event{
|
|
Kind: e.event.Kind,
|
|
Content: e.updating.content,
|
|
Tags: make(nostr.Tags, len(e.event.Tags)),
|
|
CreatedAt: nostr.Now(),
|
|
}
|
|
copy(evt.Tags, e.event.Tags)
|
|
if e.updating.title != "" {
|
|
if titleTag := evt.Tags.Find("title"); titleTag != nil {
|
|
titleTag[1] = e.updating.title
|
|
} else {
|
|
evt.Tags = append(evt.Tags, nostr.Tag{"title", e.updating.title})
|
|
}
|
|
}
|
|
if publishedAtTag := evt.Tags.Find("published_at"); publishedAtTag == nil {
|
|
evt.Tags = append(evt.Tags, nostr.Tag{
|
|
"published_at",
|
|
strconv.FormatInt(int64(e.event.CreatedAt), 10),
|
|
})
|
|
}
|
|
for ref := range nip27.ParseReferences(evt) {
|
|
tag := ref.Pointer.AsTag()
|
|
if existing := evt.Tags.FindWithValue(tag[0], tag[1]); existing == nil {
|
|
evt.Tags = append(evt.Tags, tag)
|
|
}
|
|
}
|
|
if err := e.root.signer.SignEvent(e.root.ctx, &evt); err != nil {
|
|
log("failed to sign: '%s'.\n", err)
|
|
return
|
|
}
|
|
|
|
relays := e.root.sys.FetchWriteRelays(e.root.ctx, evt.PubKey, 8)
|
|
log("publishing to %d relays... ", len(relays))
|
|
success := false
|
|
first := true
|
|
for res := range e.root.sys.Pool.PublishMany(e.root.ctx, relays, evt) {
|
|
cleanUrl, ok := strings.CutPrefix(res.RelayURL, "wss://")
|
|
if !ok {
|
|
cleanUrl = res.RelayURL
|
|
}
|
|
|
|
if !first {
|
|
log(", ")
|
|
}
|
|
first = false
|
|
|
|
if res.Error != nil {
|
|
log("%s: %s", color.RedString(cleanUrl), res.Error)
|
|
} else {
|
|
success = true
|
|
log("%s: ok", color.GreenString(cleanUrl))
|
|
}
|
|
}
|
|
log("\n")
|
|
|
|
if success {
|
|
e.event = &evt
|
|
log("event updated locally.\n")
|
|
} else {
|
|
log("failed.\n")
|
|
}
|
|
})
|
|
}
|
|
|
|
func (r *NostrRoot) FetchAndCreateEntityDir(
|
|
parent fs.InodeEmbedder,
|
|
extension string,
|
|
pointer nostr.EntityPointer,
|
|
) (*fs.Inode, error) {
|
|
event, _, err := r.sys.FetchSpecificEvent(r.ctx, pointer, sdk.FetchSpecificEventParameters{
|
|
WithRelays: false,
|
|
})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to fetch: %w", err)
|
|
}
|
|
|
|
return r.CreateEntityDir(parent, extension, event), nil
|
|
}
|
|
|
|
func (r *NostrRoot) CreateEntityDir(
|
|
parent fs.InodeEmbedder,
|
|
extension string,
|
|
event *nostr.Event,
|
|
) *fs.Inode {
|
|
return parent.EmbeddedInode().NewPersistentInode(
|
|
r.ctx,
|
|
&EntityDir{root: r, event: event, publisher: debouncer.New(time.Second * 30), extension: extension},
|
|
fs.StableAttr{Mode: syscall.S_IFDIR, Ino: hexToUint64(event.ID)},
|
|
)
|
|
}
|