opensource/podman
1
0
Fork 0
mirror of https://github.com/containers/podman.git synced 2025-05-17 23:26:08 +08:00
Code Issues Packages Projects Releases Wiki Activity

Remove in-memory state implementation

Browse Source 
We originally added this in the *very early* days of Podman,
before a proper persistent state was written, so we had something
to test with. It was retained after the original SQLite state
(and current BoltDB state) were written so it could be used for
testing Libpod in unit tests with no requirement for on-disk
storage. Well, such unit tests never materialized, and if we were
to write some now the requirement to have a temporary directory
for storing data on disk is not that bad. I can basically
guarantee there are no users of this in the wild because, even if
you managed to figure out how to configure it when we don't
document it, it's completely unusable with Podman since all your
containers and pods will disappear every time Podman exits.

Given all this, and since it's an ongoing maintenance burden I no
longer wish to deal with, let's just remove it.

Signed-off-by: Matthew Heon <matthew.heon@pm.me>
This commit is contained in:
Matthew Heon
2021-04-13 13:46:44 -04:00
parent 21d6b12689
commit 40e5ae30d5
5 changed files with 2 additions and 2078 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1706
libpod/in_memory_state.go
View File

File diff suppressed because it is too large Load Diff

6
libpod/runtime.go
View File

@ -282,11 +282,7 @@ func makeRuntime(ctx context.Context, runtime *Runtime) (retErr error) {
// package.
switch runtime.config.Engine.StateType {
case config.InMemoryStateStore:
state, err := NewInMemoryState()
if err != nil {
return err
}
runtime.state = state
return errors.Wrapf(define.ErrInvalidArg, "in-memory state is currently disabled")
case config.SQLiteStateStore:
return errors.Wrapf(define.ErrInvalidArg, "SQLite state is currently disabled")
case config.BoltDBStateStore:

28
libpod/state_test.go
View File

@ -28,8 +28,7 @@ const (
var (
testedStates = map[string]emptyStateFunc{
"in-memory": getEmptyInMemoryState,
"boltdb": getEmptyBoltState,
"boltdb": getEmptyBoltState,
}
)
@ -65,31 +64,6 @@ func getEmptyBoltState() (_ State, _ string, _ lock.Manager, retErr error) {
return state, tmpDir, lockManager, nil
}
// Get an empty in-memory state for use in tests
func getEmptyInMemoryState() (_ State, _ string, _ lock.Manager, retErr error) {
tmpDir, err := ioutil.TempDir("", tmpDirPrefix)
if err != nil {
return nil, "", nil, err
}
defer func() {
if retErr != nil {
os.RemoveAll(tmpDir)
}
}()
state, err := NewInMemoryState()
if err != nil {
return nil, "", nil, err
}
lockManager, err := lock.NewInMemoryManager(16)
if err != nil {
return nil, "", nil, err
}
return state, tmpDir, lockManager, nil
}
func runForAllStates(t *testing.T, testFunc func(*testing.T, State, lock.Manager)) {
for stateName, stateFunc := range testedStates {
state, path, manager, err := stateFunc()

127
pkg/registrar/registrar.go
View File

@ -1,127 +0,0 @@
// Package registrar provides name registration. It reserves a name to a given key.
package registrar
import (
"errors"
"sync"
)
var (
// ErrNameReserved is an error which is returned when a name is requested to be reserved that already is reserved
ErrNameReserved = errors.New("name is reserved")
// ErrNameNotReserved is an error which is returned when trying to find a name that is not reserved
ErrNameNotReserved = errors.New("name is not reserved")
// ErrNoSuchKey is returned when trying to find the names for a key which is not known
ErrNoSuchKey = errors.New("provided key does not exist")
)
// Registrar stores indexes a list of keys and their registered names as well as indexes names and the key that they are registered to
// Names must be unique.
// Registrar is safe for concurrent access.
type Registrar struct {
idx map[string][]string
names map[string]string
mu sync.Mutex
}
// NewRegistrar creates a new Registrar with the an empty index
func NewRegistrar() *Registrar {
return &Registrar{
idx: make(map[string][]string),
names: make(map[string]string),
}
}
// Reserve registers a key to a name
// Reserve is idempotent
// Attempting to reserve a key to a name that already exists results in an `ErrNameReserved`
// A name reservation is globally unique
func (r *Registrar) Reserve(name, key string) error {
r.mu.Lock()
defer r.mu.Unlock()
if k, exists := r.names[name]; exists {
if k != key {
return ErrNameReserved
}
return nil
}
r.idx[key] = append(r.idx[key], name)
r.names[name] = key
return nil
}
// Release releases the reserved name
// Once released, a name can be reserved again
func (r *Registrar) Release(name string) {
r.mu.Lock()
defer r.mu.Unlock()
key, exists := r.names[name]
if !exists {
return
}
for i, n := range r.idx[key] {
if n != name {
continue
}
r.idx[key] = append(r.idx[key][:i], r.idx[key][i+1:]...)
break
}
delete(r.names, name)
if len(r.idx[key]) == 0 {
delete(r.idx, key)
}
}
// Delete removes all reservations for the passed in key.
// All names reserved to this key are released.
func (r *Registrar) Delete(key string) {
r.mu.Lock()
for _, name := range r.idx[key] {
delete(r.names, name)
}
delete(r.idx, key)
r.mu.Unlock()
}
// GetNames lists all the reserved names for the given key
func (r *Registrar) GetNames(key string) ([]string, error) {
r.mu.Lock()
defer r.mu.Unlock()
names, exists := r.idx[key]
if !exists {
return nil, ErrNoSuchKey
}
return names, nil
}
// Get returns the key that the passed in name is reserved to
func (r *Registrar) Get(name string) (string, error) {
r.mu.Lock()
key, exists := r.names[name]
r.mu.Unlock()
if !exists {
return "", ErrNameNotReserved
}
return key, nil
}
// GetAll returns all registered names
func (r *Registrar) GetAll() map[string][]string {
out := make(map[string][]string)
r.mu.Lock()
// copy index into out
for id, names := range r.idx {
out[id] = names
}
r.mu.Unlock()
return out
}

213
pkg/registrar/registrar_test.go
View File

@ -1,213 +0,0 @@
package registrar_test
import (
"testing"
"github.com/containers/podman/v3/pkg/registrar"
. "github.com/containers/podman/v3/test/framework"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
// TestRegistrar runs the created specs
func TestRegistrar(t *testing.T) {
RegisterFailHandler(Fail)
RunSpecs(t, "Registrar")
}
// nolint: gochecknoglobals
var t *TestFramework
var _ = BeforeSuite(func() {
t = NewTestFramework(NilFunc, NilFunc)
t.Setup()
})
var _ = AfterSuite(func() {
t.Teardown()
})
// The actual test suite
var _ = t.Describe("Registrar", func() {
// Constant test data needed by some tests
const (
testKey = "testKey"
testName = "testName"
anotherKey = "anotherKey"
)
// The system under test
var sut *registrar.Registrar
// Prepare the system under test and register a test name and key before
// each test
BeforeEach(func() {
sut = registrar.NewRegistrar()
Expect(sut.Reserve(testName, testKey)).To(BeNil())
})
t.Describe("Reserve", func() {
It("should succeed to reserve a new registrar", func() {
// Given
// When
err := sut.Reserve("name", "key")
// Then
Expect(err).To(BeNil())
})
It("should succeed to reserve a registrar twice", func() {
// Given
// When
err := sut.Reserve(testName, testKey)
// Then
Expect(err).To(BeNil())
})
It("should fail to reserve an already reserved registrar", func() {
// Given
// When
err := sut.Reserve(testName, anotherKey)
// Then
Expect(err).NotTo(BeNil())
Expect(err).To(Equal(registrar.ErrNameReserved))
})
})
t.Describe("Release", func() {
It("should succeed to release a registered registrar multiple times", func() {
// Given
// When
// Then
sut.Release(testName)
sut.Release(testName)
})
It("should succeed to release a unknown registrar multiple times", func() {
// Given
// When
// Then
sut.Release(anotherKey)
sut.Release(anotherKey)
})
It("should succeed to release and re-register a registrar", func() {
// Given
// When
sut.Release(testName)
err := sut.Reserve(testName, testKey)
// Then
Expect(err).To(BeNil())
})
})
t.Describe("GetNames", func() {
It("should succeed to retrieve a single name for a registrar", func() {
// Given
// When
names, err := sut.GetNames(testKey)
// Then
Expect(err).To(BeNil())
Expect(len(names)).To(Equal(1))
Expect(names[0]).To(Equal(testName))
})
It("should succeed to retrieve all names for a registrar", func() {
// Given
testNames := []string{"test1", "test2"}
for _, name := range testNames {
Expect(sut.Reserve(name, anotherKey)).To(BeNil())
}
// When
names, err := sut.GetNames(anotherKey)
// Then
Expect(err).To(BeNil())
Expect(len(names)).To(Equal(2))
Expect(names).To(Equal(testNames))
})
})
t.Describe("GetNames", func() {
It("should succeed to retrieve a single name for a registrar", func() {
// Given
// When
names, err := sut.GetNames(testKey)
// Then
Expect(err).To(BeNil())
Expect(len(names)).To(Equal(1))
Expect(names[0]).To(Equal(testName))
})
It("should succeed to retrieve all names for a registrar", func() {
// Given
anotherKey := "anotherKey"
testNames := []string{"test1", "test2"}
for _, name := range testNames {
Expect(sut.Reserve(name, anotherKey)).To(BeNil())
}
// When
names, err := sut.GetNames(anotherKey)
// Then
Expect(err).To(BeNil())
Expect(len(names)).To(Equal(2))
Expect(names).To(Equal(testNames))
})
})
t.Describe("Delete", func() {
It("should succeed to delete a registrar", func() {
// Given
// When
sut.Delete(testKey)
// Then
names, err := sut.GetNames(testKey)
Expect(len(names)).To(BeZero())
Expect(err).To(Equal(registrar.ErrNoSuchKey))
})
})
t.Describe("Get", func() {
It("should succeed to get a key for a registrar", func() {
// Given
// When
key, err := sut.Get(testName)
// Then
Expect(err).To(BeNil())
Expect(key).To(Equal(testKey))
})
It("should fail to get a key for a not existing registrar", func() {
// Given
// When
key, err := sut.Get("notExistingName")
// Then
Expect(key).To(BeEmpty())
Expect(err).To(Equal(registrar.ErrNameNotReserved))
})
})
t.Describe("GetAll", func() {
It("should succeed to get all names", func() {
// Given
// When
names := sut.GetAll()
// Then
Expect(len(names)).To(Equal(1))
Expect(len(names[testKey])).To(Equal(1))
Expect(names[testKey][0]).To(Equal(testName))
})
})
})