110 lines
2.3 KiB
Go
110 lines
2.3 KiB
Go
package main
|
|
|
|
import (
|
|
"log"
|
|
"net"
|
|
"net/rpc"
|
|
"os"
|
|
"os/signal"
|
|
|
|
"github.com/gibheer/pkiadm"
|
|
)
|
|
|
|
const (
|
|
RTPrivateKey ResourceType = iota
|
|
RTPublicKey
|
|
RTCSR
|
|
RTCertificate
|
|
RTLocation
|
|
RTSerial
|
|
RTSubject
|
|
)
|
|
|
|
const (
|
|
ENoIDGiven = Error("no ID given")
|
|
EUnknownType = Error("unknown type found")
|
|
ENotInitialized = Error("resource not initialized")
|
|
ENotFound = Error("resource not found")
|
|
EWrongType = Error("incompatible type found - please report error")
|
|
EAlreadyExist = Error("resource already exists")
|
|
)
|
|
|
|
type (
|
|
Resource interface {
|
|
// Return the unique ResourceName
|
|
Name() ResourceName
|
|
// AddDependency registers a depending resource to be retuened by Dependencies()
|
|
// Refresh must trigger a rebuild of the resource.
|
|
Refresh(*Storage) error
|
|
// Return the PEM output of the contained resource.
|
|
Pem() ([]byte, error)
|
|
Checksum() []byte
|
|
// DependsOn must return the resource names it is depending on.
|
|
DependsOn() []ResourceName
|
|
}
|
|
|
|
ResourceName struct {
|
|
ID string
|
|
Type ResourceType
|
|
}
|
|
|
|
ResourceType uint
|
|
|
|
Error string
|
|
)
|
|
|
|
func (e Error) Error() string { return string(e) }
|
|
func (r ResourceName) String() string { return r.Type.String() + "/" + r.ID }
|
|
|
|
func main() {
|
|
os.Exit(_main())
|
|
}
|
|
|
|
func _main() int {
|
|
cfg, err := pkiadm.LoadConfig()
|
|
if err != nil {
|
|
log.Fatalf("could not load config: %s", err)
|
|
}
|
|
|
|
addr, err := net.ResolveUnixAddr("unix", cfg.Path)
|
|
if err != nil {
|
|
log.Fatalf("could not parse unix path: %s", err)
|
|
}
|
|
|
|
storage, err := NewStorage(cfg.Storage)
|
|
if err != nil {
|
|
log.Fatalf("error when loading: %s\n", err)
|
|
}
|
|
|
|
server, err := NewServer(storage)
|
|
if err != nil {
|
|
log.Fatalf("error when loading server: %s\n", err)
|
|
}
|
|
|
|
rpcServer := rpc.NewServer()
|
|
if err := rpcServer.RegisterName(pkiadm.ProtoIdent, server); err != nil {
|
|
log.Fatalf("could not bind rpc interface: %s\n", err)
|
|
}
|
|
|
|
listener, err := net.ListenUnix("unix", addr)
|
|
if err != nil {
|
|
log.Fatalf("could not open listen socket: %s", err)
|
|
}
|
|
defer os.Remove(cfg.Path)
|
|
|
|
// start signal listener
|
|
sigs := make(chan os.Signal, 1)
|
|
signal.Notify(sigs, os.Interrupt, os.Kill)
|
|
go func() {
|
|
s := <-sigs
|
|
log.Printf("initializing shutdown because of signal: %s", s)
|
|
listener.Close()
|
|
os.Remove(cfg.Path)
|
|
os.Exit(1)
|
|
}()
|
|
|
|
rpcServer.Accept(listener)
|
|
|
|
return 0
|
|
}
|