1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
package bidder
import (
"context"
"strings"
"time"
"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/internal/atproto/market"
)
func (b *Bidder) report(ctx context.Context, vm *v1alpha1.ComputeVM) {
if vm.Spec.Owner.Handle != b.cfg.ProviderHandle || vm.DeletionTimestamp != nil || b.guests.Ended(vm) {
return
}
terms := vm.Spec.Contract
if terms == nil || terms.Receipt.URI == "" || terms.Receipt.CID == "" {
return
}
held := b.guests.GuestReport(vm)
if held == nil {
return
}
published := v1alpha1.ComputeVMPublished{}
if p := b.guests.Published(vm); p != nil {
published = *p
}
now := b.now().UTC().Format(time.RFC3339)
if held.Address != "" && published.OnNetworkURI == "" {
record := market.ComputeEventsVMOnNetwork{Address: held.Address, CreatedAt: firstOf(held.ReportedAt, now)}
published = b.publishReport(ctx, vm, record, published)
}
for _, network := range held.Networks {
if network.Tag == "" || network.Address == "" || publishedNetwork(published, network.Tag) != "" {
continue
}
record := market.ComputeEventsVMOnNetwork{Tag: network.Tag, Address: network.Address, Kind: b.publishedKind(network.Tag, network.Address),
CreatedAt: firstOf(network.ReportedAt, now)}
published = b.publishReport(ctx, vm, record, published)
}
if len(held.HostKeys) > 0 && published.HostKeysURI == "" {
keys := make([]market.HostKey, 0, len(held.HostKeys))
for _, key := range held.HostKeys {
keys = append(keys, market.HostKey{Type: key.Type, PublicKey: key.PublicKey, Fingerprint: key.Fingerprint})
}
record := market.ComputeEventsVMHostKeys{Keys: keys, ObservedAt: firstOf(held.ReportedAt, now), CreatedAt: now}
b.publishReport(ctx, vm, record, published)
}
}
// ponytail: the kind of a reported network is read back from its address form until the ComputeVM guest report carries kind (plan 0034 W1-API); then publish ComputeVMGuestNetwork.Kind.
func (b *Bidder) publishedKind(tag, address string) string {
if kind := b.guests.NetworkKind(tag, address); kind == market.OnNetworkKindWebRTC {
return kind
}
return ""
}
func publishedNetwork(published v1alpha1.ComputeVMPublished, tag string) string {
for _, n := range published.Networks {
if n.Tag == tag {
return n.URI
}
}
return ""
}
func reportTag(typed market.Record) string {
if r, ok := typed.(market.ComputeEventsVMOnNetwork); ok {
return r.Tag
}
return ""
}
func firstOf(value, fallback string) string {
if value != "" {
return value
}
return fallback
}
func (b *Bidder) publishReport(ctx context.Context, vm *v1alpha1.ComputeVM, typed market.Record, report v1alpha1.ComputeVMPublished) v1alpha1.ComputeVMPublished {
collection := typed.NSID()
tag := reportTag(typed)
record, err := market.EncodeRecord(typed)
if err != nil {
b.log.Warn("encoding a market report failed", "computevm", vm.Name, "collection", collection, "err", err)
return report
}
name, err := b.ensureReportSync(ctx, vm, collection, tag, record)
if err != nil {
b.log.Warn("ensuring a market report StateSync failed", "computevm", vm.Name, "collection", collection, "err", err)
return report
}
sync, ok := b.syncs.Get(name)
if !ok || sync.Status.Phase != v1alpha1.StateSyncPhaseAcked || sync.Status.Acked == nil {
return report
}
uri := strings.TrimSpace(sync.Status.Acked.Ref)
if uri == "" {
return report
}
switch {
case collection == market.ComputeEventsVMOnNetworkNSID && tag != "":
report.Networks = append(report.Networks, v1alpha1.ComputeVMPublishedNetwork{Tag: tag, URI: uri})
case collection == market.ComputeEventsVMOnNetworkNSID:
report.OnNetworkURI = uri
default:
report.HostKeysURI = uri
}
if err := b.intents.ApplyComputeVMPublished(ctx, vm.Name, report); err != nil {
if ctx.Err() == nil {
b.log.Warn("recording a ComputeVM market report URI failed", "computevm", vm.Name, "err", err)
}
return report
}
b.log.Info("a ComputeVM market report is recorded", "computevm", vm.Name, "collection", collection, "tag", tag, "payload", uri)
return report
}
