/**
* Parse a serialized RegNode, returning one with an open acceptor.
*/
func ParseRegNodeFromStrings(ss []string) (
rn *RegNode, rest []string, err error) {
var (
line string
node *xn.Node
ckPriv *rsa.PrivateKey
skPriv *rsa.PrivateKey
)
rest = ss
line, err = xc.NextNBLine(&rest)
if (err == nil) && (line != "regNode {") {
err = MissingRegNodeLine
} else {
node, rest, err = xn.ParseFromStrings(rest)
if err == nil {
line, err = xc.NextNBLine(&rest)
if err == nil {
parts := strings.Split(line, ": ")
if parts[0] == "ckPriv" && parts[1] == "-----BEGIN -----" {
ckPriv, err = xn.ExpectRSAPrivateKey(&rest)
} else {
err = MissingPrivateKey
}
if err == nil {
line, err = xc.NextNBLine(&rest)
if err == nil {
parts := strings.Split(line, ": ")
if parts[0] == "skPriv" && parts[1] == "-----BEGIN -----" {
skPriv, err = xn.ExpectRSAPrivateKey(&rest)
} else {
err = MissingPrivateKey
}
if err == nil {
line, err = xc.NextNBLine(&rest)
if (err == nil) && (line != "}") {
err = MissingClosingBrace
}
if err == nil {
// Try to open the acceptor.
err = node.OpenAcc()
if err == nil {
rn, err = NewRegNode(node, ckPriv, skPriv)
}
}
}
}
}
}
}
}
return
}
func NewEphServer() (ms *EphServer, err error) {
// Create an XLattice node with quasi-random parameters including
// low-quality keys and an endPoint in 127.0.0.1, localhost.
var (
ckPriv, skPriv *rsa.PrivateKey
rn *RegNode
ep *xt.TcpEndPoint
node *xn.Node
reg *Registry
server *RegServer
)
rng := xr.MakeSimpleRNG()
name := rng.NextFileName(16)
idBuf := make([]byte, xu.SHA1_BIN_LEN)
rng.NextBytes(idBuf)
lfs := "tmp/" + hex.EncodeToString(idBuf)
id, err := xi.New(nil)
if err == nil {
// XXX cheap keys, too weak for any serious use
ckPriv, err = rsa.GenerateKey(rand.Reader, 1024)
if err == nil {
skPriv, err = rsa.GenerateKey(rand.Reader, 1024)
}
}
if err == nil {
ep, err = xt.NewTcpEndPoint("127.0.0.1:0")
eps := []xt.EndPointI{ep}
if err == nil {
node, err = xn.New(name, id, lfs, ckPriv, skPriv, nil, eps, nil)
if err == nil {
err = node.OpenAcc() // so acceptors are now live
if err == nil {
rn, err = NewRegNode(node, ckPriv, skPriv)
if err == nil {
// DEBUG
if rn == nil {
fmt.Println("regNode is NIL!\n")
} else {
fmt.Printf("eph server listening on %s\n",
rn.GetAcceptor(0).String())
}
// END
// a registry with no clusters and no logger
opt := &RegOptions{
EndPoint: ep, // not used
Ephemeral: true,
GlobalEndPoint: node.GetEndPoint(0),
Lfs: lfs, // redundant (is in node's BaseNode)
Logger: nil,
K: DEFAULT_K,
M: DEFAULT_M,
}
reg, err = NewRegistry(nil, rn, opt)
if err == nil {
server, err = NewRegServer(reg, true, 1)
if err == nil {
ms = &EphServer{
acc: rn.GetAcceptor(0),
Server: server,
}
}
}
}
}
}
}
}
return
}
func setup(opt *reg.RegOptions) (rs *reg.RegServer, err error) {
// If LFS/.xlattice/reg.config exists, we load that. Otherwise we
// create a node. In either case we force the node to listen on
// the designated port
var (
e []xt.EndPointI
node *xn.Node
pathToConfigFile string
rn *reg.RegNode
ckPriv, skPriv *rsa.PrivateKey
)
logger := opt.Logger
verbose := opt.Verbose
greetings := fmt.Sprintf("xlReg v%s %s start run\n",
reg.VERSION, reg.VERSION_DATE)
if verbose {
fmt.Print(greetings)
}
logger.Print(greetings)
pathToConfigFile = path.Join(path.Join(opt.Lfs, ".xlattice"), "reg.config")
found, err := xf.PathExists(pathToConfigFile)
if err == nil {
if found {
logger.Printf("Loading existing reg config from %s\n",
pathToConfigFile)
// The registry node already exists. Parse it and we are done.
var data []byte
data, err = ioutil.ReadFile(pathToConfigFile)
if err == nil {
rn, _, err = reg.ParseRegNode(string(data))
}
} else {
logger.Println("No config file found, creating new registry.")
// We need to create a registry node from scratch.
nodeID, _ := xi.New(nil)
ep, err := xt.NewTcpEndPoint(opt.Address + ":" + opt.Port)
if err == nil {
e = []xt.EndPointI{ep}
ckPriv, err = rsa.GenerateKey(rand.Reader, 2048)
if err == nil {
skPriv, err = rsa.GenerateKey(rand.Reader, 2048)
}
if err == nil {
node, err = xn.New("xlReg", nodeID, opt.Lfs, ckPriv, skPriv,
nil, e, nil)
if err == nil {
node.OpenAcc() // XXX needs a complementary close
if err == nil {
// DEBUG
fmt.Printf("XLattice node successfully created\n")
fmt.Printf(" listening on %s\n", ep.String())
// END
rn, err = reg.NewRegNode(node, ckPriv, skPriv)
if err == nil {
// DEBUG
fmt.Printf("regNode successfully created\n")
// END
err = xf.MkdirsToFile(pathToConfigFile, 0700)
if err == nil {
err = ioutil.WriteFile(pathToConfigFile,
[]byte(rn.String()), 0400)
// DEBUG
} else {
fmt.Printf("error writing config file: %v\n",
err.Error())
}
// END --------------
// DEBUG
} else {
fmt.Printf("error creating regNode: %v\n",
err.Error())
// END
}
}
}
}
}
}
}
if err == nil {
var r *reg.Registry
r, err = reg.NewRegistry(nil, // nil = clusters so far
rn, opt) // regNode, options
if err == nil {
logger.Printf("Registry name: %s\n", rn.GetName())
logger.Printf(" ID: %s\n", rn.GetNodeID().String())
}
if err == nil {
var verbosity int
if opt.Verbose {
verbosity++
}
rs, err = reg.NewRegServer(r, opt.Testing, verbosity)
}
}
if err != nil {
logger.Printf("ERROR: %s\n", err.Error())
}
return
}