def configure(path):
configure = cfg(path)
target_list = []
arch = configure.get_build_options(target_list)
for t in target_list:
create_target_makefile(t, arch)
print("Creating %s/Makefile..." % (os.path.dirname(path)))
try:
make_file = open("Makefile", "x")
except:
make_file = open("Makefile", "w")
make_file.write(".PHONY : all clean delete rebuild\n")
#all
make_file.write("all :\n")
for t in target_list:
make_file.write("\tcd %s;make all\n" % (t[0]))
#clean
make_file.write("clean :\n")
for t in target_list:
make_file.write("\tcd %s;make clean\n" % (t[0]))
#delete
make_file.write("delete :\n")
for t in target_list:
make_file.write("\tcd %s;make delete\n" % (t[0]))
#rebuild
make_file.write("rebuild :\n")
for t in target_list:
make_file.write("\tcd %s;make rebuild\n" % (t[0]))
return
def getNewDatabaseId():
"""Get the id of a new database to create"""
try:
databaseId = int(cfg("dbid"))
return databaseId
except KeyError:
warning("Can't find dbid in config")
print("please supply a globally unique number")
while True:
databaseId = raw_input("New databaseId:")
try:
databaseId = int(databaseId)
return databaseId
except ValueError:
print("Must be a whole number")
if databaseId <= 0:
print("Must be greater than zero")
def guessDatabaseName():
"""Make an educated guess at the database name to use in this folder"""
# First ask the config if a dbpath has been provided
# as that overrides all other options.
try:
dbpath = cfg("dbpath", default=None)
return dbpath
except KeyError:
warning("no dbpath in config, scanning directory instead")
# get list of databases in current folder (files with name *.db)
import glob
candidateNames = glob.glob("*.db")
if len(candidateNames) == 0:
# No databases in folder
return DEFAULT_DATABASE_NAME # use a sensible default
elif len(candidateNames) == 1:
return (candidateNames[0])[:-3] # use the only one, but strip extension
else:
# N databases in folder
# Provide a list for the user to choose from
i = 1
print("CHOOSE A DATABASE")
for n in candidateNames:
print(str(i) + ". " + n)
i += 1
while True:
choice = raw_input("Open which database?")
try:
choice = int(choice)
if choice < 1 or choice > len(candidateNames):
print("Must choose a number between 1 and " + str(len(candidateNames)))
else:
return (candidateNames[choice-1])[:-3] # strip extension
except ValueError:
print("Must choose a number")
def init(nodeName, ownerName=None, dbPath=None, linkPath=None):
global myOwnerName, myOwner
global myNodeName, myNode
# Set some sensible defaults, if caller does not provide them
if nodeName == None:
nodeName = DEFAULT_NODE_NAME + "#" + str(random.randint(0,65535))
if linkPath == None:
linkPath = cfg("lanaddr", default=None)
if linkPath == None:
linkPath = DEFAULT_LINKADDR
myOwner = Owner.use(ownerName, linkPath=linkPath, dbPath=dbPath)
myOwnerName = myOwner.ownerName
state = myOwner.getStateForNode(nodeName)
myNodeName = nodeName
if state == None: # not yet created
myNode = Node.create(nodeName, owner=myOwner)
myNode.loop()
return True # we just Initialised
return False # we didn't need to init the Node
def init(nodeName, ownerName=None, dbPath=None, linkPath=None):
global myOwnerName, myOwner
global myNodeName, myNode
# Set some sensible defaults, if caller does not provide them
if nodeName == None:
nodeName = DEFAULT_NODE_NAME + "#" + str(random.randint(0, 65535))
if linkPath == None:
linkPath = cfg("lanaddr", default=None)
if linkPath == None:
linkPath = DEFAULT_LINKADDR
myOwner = Owner.use(ownerName, linkPath=linkPath, dbPath=dbPath)
myOwnerName = myOwner.ownerName
state = myOwner.getStateForNode(nodeName)
myNodeName = nodeName
if state == None: # not yet created
myNode = Node.create(nodeName, owner=myOwner)
myNode.loop()
return True # we just Initialised
return False # we didn't need to init the Node
def __init__(self, ownerName, databaseId, dbPath=None, linkPath=None):
if databaseId == None:
raise ValueError("Must provide a databaseId")
if linkPath == None:
linkPath = cfg("lanaddr", default=None)
self.ownerName = ownerName
self.dbPath = dbPath
self.linkPath = linkPath
self.databaseId = databaseId
#TODO: refactor as makeMeta() to be consistent with makeData()
if linkPath != None:
address = Link.MulticastNetConnection.getAddress(linkPath)
port = Link.MulticastNetConnection.getPort(linkPath)
self.meta_link = Link.MulticastNetConnection(name="VS.Owner", address=address, port=port)
else:
self.meta_link = Link.MulticastNetConnection(name="VS.Owner")
self.meta = Link.Meta(link=self.meta_link, dbPath=dbPath, databaseId=databaseId)
ownerId = self.meta.getOwnerId(ownerName)
if ownerId == None:
#trace("SIGNUP")
ownerId = self.meta.signup(ownerName, databaseId)
else:
#trace("LOGIN")
ownerId = self.meta.login(ownerName, databaseId)
#trace("ownerId:" + str(ownerId))
if ownerId == None:
raise ValueError("Owner not created")
self.ownerId = ownerId
anyAddr = Address.EMPTY
#trace("Owner registers listener for handleMeta")
#TODO could be more restrictive in registration
#i.e. dst=(o), so that filtering is done earlier.
self.meta.registerListener(None, anyAddr, anyAddr, self.handleMeta)
def __init__(self, wsgi_callable=None, **kwargs):
self.wsgi_callable = wsgi_callable
self.cfg = getattr(wsgi_callable, 'cfg', None) or cfg()
super().__init__(**kwargs)
self.headers['X-Http-Local'] = 'local'
def __init__(self, wsgi_callable=None, **kwargs):
self.wsgi_callable = wsgi_callable
self.cfg = getattr(wsgi_callable, 'cfg', None) or cfg()
super().__init__(**kwargs)
self.headers['X-Http-Local'] = 'local'
def find(self, pointName, ownerName=None, nodeName=None, wait=True, timeout=None, pointType=None):
"""Find a specific node and it's point"""
#trace("Node.find:" + str(ownerName) + " " + str(nodeName) + " " + str(pointName))
if pointType == None:
pointType = Point.GENERIC
if timeout == None:
timeout = cfg("find.timeout", default=60)
# Find a reference to the Owner
if ownerName == None:
ownerId = self.owner.ownerId
else:
ownerId = self.meta.getOwnerId(ownerName)
if ownerId == None:
raise ValueError("Owner not found:" + ownerName)
#TODO insert whois poll pattern here
# find a reference to the Node
if nodeName == None:
nodeAddr = (self.owner.databaseId, self.nodeId)
else:
nodeAddr = self.meta.getNodeAddr(ownerId, nodeName)
if nodeAddr == None:
if wait: # wait for node to be created
trace("warning: waiting for node:" + nodeName)
now = time.time()
tout = now + timeout
while now < tout:
self.meta.whoisNode(ownerId, nodeName)
self.loop()
nodeAddr = self.meta.getNodeAddr(ownerId, nodeName)
if nodeAddr != None:
trace("found node:" + nodeName)
break
now = time.time()
time.sleep(WHOIS_POLL_RATE) # poll rate to limit whois messaging
if nodeAddr == None:
raise ValueError("timeout waiting for Node:" + nodeName)
else:
raise ValueError("node not found:" + nodeName)
# find a reference to the Point
databaseId = nodeAddr[0]
nodeId = nodeAddr[1]
pointId = self.meta.getPointId(ownerId, nodeId, pointName, databaseId=databaseId)
if pointId == None:
if wait: # wait for node to be created
trace("warning: waiting for point:" + pointName)
now = time.time()
tout = now + timeout
while now < tout:
self.meta.whoisPoint(ownerId, databaseId, nodeId, pointName)
self.loop()
pointId = self.meta.getPointId(ownerId, nodeId, pointName, databaseId=databaseId)
if pointId != None:
trace("found point:" + pointName)
break
now = time.time()
time.sleep(WHOIS_POLL_RATE) # poll rate to limit whois messaging
if pointId == None:
raise ValueError("timeout waiting for point:" + pointName)
else:
raise ValueError("point not found:" + pointName)
#TODO should really check that the point is ADVERTISED
# create a proxy reference object to the remote Point
pointType = self.meta.getPointType(ownerId, nodeId, pointId, databaseId=databaseId)
endType = Point.REMOTE
p = Point.metaRestore(pointType, endType, ownerId, nodeId, pointName, pointId, self.meta, self.data, databaseId=databaseId)
return p
# CONFIGURATION --------------------------------------------------------
# Knit up to the underlying transport
# This should be the only thing to change when moving to new transport
import sandbox.Link as Link
#TODO: deprecate this
DEFAULT_DATABASE_NAME = "test"
DEFAULT_OWNER_NAME = "tester"
#DEFAULT_NODE_NAME = "node" [instance]
#DEFAULT_POINT_NAME = "point" [instance]
WHOIS_POLL_RATE = cfg("whois.pollrate", default=5)
# This allows VirtualSpace.CONSUMER and VirtualSpace.PRODUCER
# if all you do is import VirtualSpace. But really they are types of
# Point and don't really belong here long term.
# They are duplicated in Link.py as it needs a verb to send over the
# wire - that's fine for now, at least they are linked.
def trace(msg):
print(str(msg))
def warning(msg):
print("warning:" + str(msg))