ayurishchevandClaude Sonnet 5
582b44f314
Adds POST /api/v1/admin/ips/scan (plus an optional periodic ticker) to
discover free Floating IPs in the OpenStack project and feed them straight
into the check queue. More importantly, decouples check/event history from
ip_queue's lifecycle: a new ip_registry table (migration 0007) gives every
address ever submitted a durable identity, so deleting it from the queue no
longer destroys its history — it's still reachable via the new
GET /api/v1/admin/registry[/{ip}] endpoints and the dashboard's /registry
pages, with retention depth configurable in check cycles per address
(history_retention_cycles, 0 = unlimited).
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
98 lines
2.6 KiB
Go
98 lines
2.6 KiB
Go
package openstack
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"sync"
|
|
)
|
|
|
|
// MockClient is an in-memory FloatingIPClient used by unit tests and the
|
|
// offline end-to-end harness. Seed it with the pool of floating IPs the
|
|
// scenario expects to exist before use.
|
|
type MockClient struct {
|
|
mu sync.Mutex
|
|
fips map[string]*FloatingIP // keyed by ID
|
|
byIP map[string]string // address -> ID
|
|
|
|
// AssociateFailures/DisassociateFailures let tests force a failure for
|
|
// a specific floating-IP ID on its next call, to exercise retry paths.
|
|
AssociateFailures map[string]error
|
|
DisassociateFailures map[string]error
|
|
}
|
|
|
|
func NewMockClient() *MockClient {
|
|
return &MockClient{
|
|
fips: make(map[string]*FloatingIP),
|
|
byIP: make(map[string]string),
|
|
}
|
|
}
|
|
|
|
// Seed registers a floating IP as if pre-allocated in the service project.
|
|
func (m *MockClient) Seed(id, address, projectID string) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
m.fips[id] = &FloatingIP{ID: id, Address: address, ProjectID: projectID}
|
|
m.byIP[address] = id
|
|
}
|
|
|
|
// SeedWithPort registers a floating IP as already associated to portID —
|
|
// for simulating a FIP that's occupied (e.g. by another VM's port) before a
|
|
// test's Tick runs.
|
|
func (m *MockClient) SeedWithPort(id, address, projectID, portID string) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
m.fips[id] = &FloatingIP{ID: id, Address: address, ProjectID: projectID, PortID: portID}
|
|
m.byIP[address] = id
|
|
}
|
|
|
|
func (m *MockClient) GetFloatingIPByAddress(ctx context.Context, address string) (*FloatingIP, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
id, ok := m.byIP[address]
|
|
if !ok {
|
|
return nil, ErrNotFound(address)
|
|
}
|
|
f := *m.fips[id]
|
|
return &f, nil
|
|
}
|
|
|
|
func (m *MockClient) ListFloatingIPs(ctx context.Context) ([]FloatingIP, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
out := make([]FloatingIP, 0, len(m.fips))
|
|
for _, f := range m.fips {
|
|
out = append(out, *f)
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (m *MockClient) AssociateFloatingIP(ctx context.Context, fipID, portID string) error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
if err := m.AssociateFailures[fipID]; err != nil {
|
|
delete(m.AssociateFailures, fipID)
|
|
return err
|
|
}
|
|
f, ok := m.fips[fipID]
|
|
if !ok {
|
|
return fmt.Errorf("mock openstack: unknown floating ip %q", fipID)
|
|
}
|
|
f.PortID = portID
|
|
return nil
|
|
}
|
|
|
|
func (m *MockClient) DisassociateFloatingIP(ctx context.Context, fipID string) error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
if err := m.DisassociateFailures[fipID]; err != nil {
|
|
delete(m.DisassociateFailures, fipID)
|
|
return err
|
|
}
|
|
f, ok := m.fips[fipID]
|
|
if !ok {
|
|
return fmt.Errorf("mock openstack: unknown floating ip %q", fipID)
|
|
}
|
|
f.PortID = ""
|
|
return nil
|
|
}
|