func init() {
var err error
serverVersion, err = xu.ParseDecimalVersion(VERSION)
if err != nil {
panic(err)
}
}
func init() {
// msgHandlers = make([][]interface{}, BYE_RCVD, MSG_HANDLER_COUNT)
msgHandlers = [][]interface{}{
// client messages permitted in HELLO_RCVD state
{doClientMsg, badCombo, badCombo, badCombo, doByeMsg},
// messages permitted in CLIENT_DETAILS_RCVD
{badCombo, doCreateMsg, doJoinMsg, badCombo, doByeMsg},
// messages permitted in CREATE_REQUEST_RCVD
{badCombo, badCombo, doJoinMsg, badCombo, doByeMsg},
// messages permitted in JOIN_RCVD
{badCombo, badCombo, badCombo, doGetMsg, doByeMsg},
}
var err error
serverVersion, err = xu.ParseDecimalVersion(VERSION)
if err != nil {
panic(err)
}
}
func NewUpaxServer(ckPriv, skPriv *rsa.PrivateKey, cm *xcl.ClusterMember,
whichSHA int) (us *UpaxServer, err error) {
var (
count int
lfs string // path to local file system
f *os.File // file for debugging log
pathToLog string
logger *log.Logger
uDir u.UI
pathToU string
entries *xi.IDMap
ftLogFile *os.File
pathToFTLog string // conventionally lfs/U/L
)
if ckPriv == nil || ckPriv == nil {
err = NilRSAKey
} else if cm == nil {
err = NilClusterMember
}
if err == nil {
serverVersion, err = xu.ParseDecimalVersion(VERSION)
}
if err == nil {
// whatever created cm should have created the local file system
// and written the node configuration to
// LFS/.xlattice/cluster.member.config. Let's make sure that
// that exists before proceeding.
lfs = cm.GetLFS()
// This should be passed in opt.Logger
pathToLog = filepath.Join(lfs, "log")
f, err = os.OpenFile(pathToLog,
os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0640)
if err == nil {
logger = log.New(f, "", log.Ldate|log.Ltime)
}
pathToCfg := filepath.Join(
filepath.Join(lfs, ".xlattice"), "cluster.member.config")
var found bool
found, err = xf.PathExists(pathToCfg)
if err == nil && found == false {
err = ClusterConfigNotFound
}
}
if f != nil {
defer f.Close()
}
if err == nil {
// DEBUG
fmt.Printf("creating directory tree in %s\n", lfs)
// END
pathToU = filepath.Join(lfs, "U")
uDir, err = u.New(pathToU, u.DIR16x16, 0)
}
if err == nil {
entries, err = xi.NewNewIDMap() // with default depth
}
if err == nil {
var found bool
pathToFTLog = filepath.Join(pathToU, "L")
found, err = xf.PathExists(pathToFTLog)
if err == nil {
if found {
fmt.Printf("ftLog file exists\n")
count, err = loadEntries(pathToFTLog, entries, whichSHA)
if err == nil {
// reopen it 0600 for appending
ftLogFile, err = os.OpenFile(pathToFTLog,
os.O_WRONLY|os.O_APPEND, 0600)
}
} else {
// open it for appending
ftLogFile, err = os.OpenFile(pathToFTLog,
os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0600)
}
}
}
if err == nil {
us = &UpaxServer{
DoneCh: make(chan bool, 2),
PathToDebugLog: pathToLog,
Logger: logger,
uDir: uDir,
entries: entries,
ftLogFile: ftLogFile,
pathToFTLog: pathToFTLog,
entryCount: count,
ckPriv: ckPriv,
skPriv: skPriv,
ClusterMember: *cm,
}
}
return
}
func ParseRegCred(s string) (rc *RegCred, err error) {
var (
line string
parts []string
name string
nodeID *xi.NodeID
ck, sk *rsa.PublicKey
e []xt.EndPointI
version xu.DecimalVersion
)
ss := strings.Split(s, "\n")
line, err = xc.NextNBLine(&ss)
if (err == nil) && (line != "regCred {") {
err = IllFormedRegCred
}
if err == nil {
line, err = xc.NextNBLine(&ss)
if err == nil {
parts = strings.Split(line, ": ")
if len(parts) == 2 && parts[0] == "Name" {
name = strings.TrimLeft(parts[1], " \t")
} else {
err = IllFormedRegCred
}
}
}
if err == nil {
var id []byte
line, err = xc.NextNBLine(&ss)
if err == nil {
parts = strings.Split(line, ": ")
if len(parts) == 2 && parts[0] == "ID" {
id, err = hex.DecodeString(parts[1])
} else {
err = IllFormedRegCred
}
}
if err == nil {
nodeID, err = xi.New(id)
}
}
if err == nil {
line, err = xc.NextNBLine(&ss)
if err == nil {
parts = strings.Split(line, ": ")
if len(parts) == 2 && parts[0] == "CommsPubKey" {
ck, err = xc.RSAPubKeyFromDisk([]byte(parts[1]))
} else {
err = IllFormedRegCred
}
}
}
if err == nil {
line, err = xc.NextNBLine(&ss)
if err == nil {
parts = strings.Split(line, ": ")
if len(parts) == 2 && parts[0] == "SigPubKey" {
sk, err = xc.RSAPubKeyFromDisk([]byte(parts[1]))
} else {
err = IllFormedRegCred
}
}
}
if err == nil {
line, err = xc.NextNBLine(&ss)
if err == nil {
// collect EndPoints section; this should be turned into a
// utility function
if line == "EndPoints {" {
for err == nil {
line = strings.TrimSpace(ss[0]) // peek
if line == "}" {
break
}
line, err = xc.NextNBLine(&ss)
if err == nil {
line = strings.TrimSpace(line)
parts := strings.Split(line, ": ")
if len(parts) != 2 || parts[0] != "TcpEndPoint" {
err = IllFormedRegCred
} else {
var ep xt.EndPointI
ep, err = xt.NewTcpEndPoint(parts[1])
if err == nil {
e = append(e, ep)
}
}
}
}
if err == nil {
line, err = xc.NextNBLine(&ss)
if (err == nil) && (line != "}") {
err = MissingClosingBrace
}
}
} else {
err = MissingEndPointsSection
}
}
}
if err == nil {
line, err = xc.NextNBLine(&ss)
if err == nil {
parts = strings.Split(line, ": ")
if len(parts) == 2 && parts[0] == "Version" {
version, err = xu.ParseDecimalVersion(parts[1])
} else {
err = IllFormedRegCred
}
}
}
if err == nil {
rc = &RegCred{
Name: name,
ID: nodeID,
CommsPubKey: ck,
SigPubKey: sk,
EndPoints: e,
Version: version,
}
}
return
}
func NewRegistry(clusters []*RegCluster,
rn *RegNode,
opt *RegOptions) (
reg *Registry, err error) {
var (
idFilter xf.BloomSHAI
m ha.HAMT
serverVersion xu.DecimalVersion
)
serverVersion, err = xu.ParseDecimalVersion(VERSION)
if err == nil && rn == nil {
err = NilRegNode
}
if err == nil {
if opt.BackingFile == "" {
idFilter, err = xf.NewBloomSHA(opt.M, opt.K)
} else {
idFilter, err = xf.NewMappedBloomSHA(opt.M, opt.K, opt.BackingFile)
}
if err == nil {
// HAMT root table size is 2^opt.T
m, err = ha.NewHAMT(DEFAULT_W, opt.T)
}
}
if err == nil {
logger := opt.Logger
if logger == nil {
logger = log.New(os.Stderr, "", log.Ldate|log.Ltime)
}
testing := opt.Testing
// DEBUG
if testing {
logger.Printf("testing and globalEndPoint = %s\n", opt.GlobalEndPoint)
}
// END
reg = &Registry{
idFilter: idFilter,
Clusters: clusters,
GlobalEndPoint: opt.GlobalEndPoint, // written to regCred
ClustersByName: make(map[string]*RegCluster),
ClustersByID: m,
Logger: logger,
RegNode: *rn,
}
if clusters != nil {
// XXX need to populate the indexes here
}
myLFS := rn.GetLFS()
if myLFS != "" {
var ep []xt.EndPointI
// list of endpoints for regCred
//for i := 0; i < rn.SizeEndPoints(); i++ {
// ep = append(ep, rn.GetEndPoint(i))
//}
// XXX err should never be nil here
if err == nil {
ep = append(ep, opt.GlobalEndPoint)
regCred := &RegCred{
Name: rn.GetName(),
ID: rn.GetNodeID(),
CommsPubKey: rn.GetCommsPublicKey(),
SigPubKey: rn.GetSigPublicKey(),
EndPoints: ep,
Version: serverVersion,
}
serialized := regCred.String() // shd have terminating CRLF
logger.Print(serialized)
pathToFile := filepath.Join(myLFS, "regCred.dat")
err = ioutil.WriteFile(pathToFile, []byte(serialized), 0644)
}
}
}
if err == nil {
// registry's own ID added to Bloom filter
regID := rn.GetNodeID()
// DEBUG
reg.Logger.Printf("\ninserting registry ID %x\n", regID.Value())
// END
err = reg.InsertID(regID)
}
return
}