ayurishchevandClaude Sonnet 5.5
cd37b10f3b
An admin-controlled scenario that repeats what the operator does by hand: clear the IP queue, scan and enqueue all free Floating IPs, wait until every queued address reaches a terminal state (so results are in the Registry), then wait a configurable interval and start over. - control-api: new auto_cycle singleton table (migration 0008) holding enabled/interval/max-run settings and persisted phase state, so the cycle survives restarts; engine in orchestrator/autocycle.go driven from the existing loop tick with an injectable "now" for deterministic tests. - Interval (default 1h, min 60s) and max wait (default unlimited, timeout outcome) are runtime settings, never hardcoded. - The periodic fip_scan_interval_seconds scan is skipped while the cycle is enabled. An emptied queue mid-cycle counts as finished; stopping during the pause keeps the last cycle's outcome. - API: GET/PUT /api/v1/admin/auto-cycle, POST .../start, POST .../stop. - admin-dashboard: "Автоматический цикл" panel on /settings and an "Автоцикл активен" indicator on /overview. - Tests for db, orchestrator, httpapi and dashboard; run-local-e2e.sh now exercises a full auto cycle; docs updated; bin/ rebuilt with refreshed SHA256SUMS. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
105 lines
2.8 KiB
Go
105 lines
2.8 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
|
|
|
|
// ListFailure, when non-nil, is returned by every ListFloatingIPs call
|
|
// until the test resets it to nil — to exercise the scan-error path.
|
|
ListFailure 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()
|
|
if m.ListFailure != nil {
|
|
return nil, m.ListFailure
|
|
}
|
|
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
|
|
}
|