def __init__(self, serviceName = u'FluidNexus', database = None, library="e32"):
"""Initialize the server be setting up the server socket and advertising the FluidNexus service."""
log.write("Starting Fluid Nexus Server")
# Save our database object
self.database = database
# Save our service name
self.serviceName = serviceName
self.mutex = thread.allocate_lock()
self.library = library
# Setup our server socket
if (self.library == "e32"):
self.serverSocket = socket.socket(socket.AF_BT, socket.SOCK_STREAM)
self.serverPort = socket.bt_rfcomm_get_available_server_channel(self.serverSocket)
self.serverSocket.bind(("", self.serverPort))
self.serverSocket.listen(self.numberConnections)
socket.bt_advertise_service(self.serviceName, self.serverSocket, True, socket.RFCOMM)
# Remove security protections
# @TODO@ Make sure this actually does what we want it to do!
socket.set_security(self.serverSocket, 0)
elif (self.library == "lightblue"):
self.serverSocket = lightblue.socket()
self.serverSocket.bind(("", 0))
self.serverSocket.listen(self.numberConnections)
lightblue.advertise(self.serviceName, self.serverSocket, lightblue.RFCOMM)
def chat_server():
server = socket.socket(socket.AF_BT, socket.SOCK_STREAM)
channel = socket.bt_rfcomm_get_available_server_channel(server)
server.bind(("", channel))
server.listen(1)
socket.bt_advertise_service(u"btchat", server, True, socket.RFCOMM)
socket.set_security(server, socket.AUTH | socket.AUTHOR)
print "Waiting for clients..."
conn, client_addr = server.accept()
print "Client connected!"
talk(conn, None)
def initMessageAdvertisements(self):
"""Initialize the advertisement of hashes that have been sent to us."""
# @TODO@ Use the correct database here :-)
#self.database.query('select * from FluidNexusStigmergy')
self.database.services()
self.messageHashes = []
for item in self.database:
# @TODO@ This can break if we change the database schema
# Get the last item (the hash)
self.messageHashes.append('%s' % item[-1])
# If there is nothing in the FluidNexusStigmergy database, return now
if len(self.messageHashes) == 0:
return
# @HACK@
# For some reason we have to do this convoluted process below, otherwise sockets get reused or don't advertise properly.
# Meaning, we have to create the sockets beforehand, and then loop through them to advertise with the desired hashes.
# This seems strange, because we create the sockets anew before we advertise them, so it seems like some kind of race condition.
# Get the number of hashes to advertise
numAdvertise = len(self.messageHashes)
# Create all of our advertisingSockets
self.advertisingSockets = {}
for counter in range(0, len(self.messageHashes)):
if (self.library == "e32"):
self.advertisingSockets[self.messageHashes[counter]] = socket.socket(socket.AF_BT, socket.SOCK_STREAM)
elif (self.library == "lightblue"):
self.advertisingSockets[self.messageHashes[counter]] = lightblue.socket()
# Now, do what we need to with the sockets
for item in self.advertisingSockets.items():
hash = item[0]
s = item[1]
if (self.library == "e32"):
tempPort = socket.bt_rfcomm_get_available_server_channel(s)
s.bind(("", tempPort))
s.listen(1)
socket.bt_advertise_service(unicode(':' + hash), s, True, socket.RFCOMM)
elif (self.library == "lightblue"):
s.bind(("", 0))
s.listen(1)
lightblue.advertise(unicode(':' + hash), s, lightblue.RFCOMM)
def advertiseNewHash(self, hash):
"""Advertise a new hash that we have just received."""
log.write(str(hash))
if (self.library == "e32"):
newSocket = socket.socket(socket.AF_BT, socket.SOCK_STREAM)
self.advertisingSockets[hash] = newSocket
tempPort = socket.bt_rfcomm_get_available_server_channel(newSocket)
newSocket.bind(("", tempPort))
newSocket.listen(1)
socket.bt_advertise_service(unicode(':' + hash), newSocket, True, socket.RFCOMM)
elif (self.library == "lightblue"):
newSocket = lightblue.socket()
self.advertisingSockets[hash] = newSocket
newSocket.bind(("", 0))
newSocket.listen(1)
lightblue.advertise(unicode(":" + hash), newSocket, lightblue.RFCOMM)
def _getavailableport(sock):
# can just use bt_rfcomm_get_available_server_channel since only RFCOMM is
# currently supported
return _socket.bt_rfcomm_get_available_server_channel(sock._sock)
def __init__(self):
self.sock = socket.socket(socket.AF_BT, socket.SOCK_STREAM)
self.host = ""
self.port = socket.bt_rfcomm_get_available_server_channel(self.sock)
connected = False
if msg:
heartbeat_start = time.time()
eval_msg(msg)
try:
app_lock.signal()
except:
pass
global server_socket, client_socket, connected, shutdown, timer, app_lock, heartbeat_timeout, heartbeat_start
connected = False
server_socket = socket.socket(socket.AF_BT, socket.SOCK_STREAM)
server_socket.setblocking(False)
port = socket.bt_rfcomm_get_available_server_channel(server_socket)
server_socket.bind(("", port))
server_socket.listen(5)
socket.bt_advertise_service(u"Bluetooth Server", server_socket, True,
socket.RFCOMM)
socket.set_security(server_socket, socket.AUTHOR)
while not shutdown:
timer.cancel()
if connected:
#print "heartbeat_timeout;", heartbeat_timeout, ",", "time.time()-heartbeat_start", time.time()-heartbeat_start
if (time.time() - heartbeat_start) > heartbeat_timeout:
disconnect_client()
continue
timer.after(0.1, recv_msg)
#from bluetooth import *
import socket
import select
import sys
import time
from watch import parser
myparser = parser()
# Create server for clock to connect to
server = socket.socket(socket.AF_BT, socket.SOCK_STREAM, socket.BTPROTO_RFCOMM)
print server._sock
channel = socket.bt_rfcomm_get_available_server_channel(server._sock)
#channel = 1
print channel
server.bind(("", channel))
socket.bt_advertise_service(u"Serial", server._sock, True, socket.RFCOMM)
socket.set_security(server._sock, socket.AUTHOR)
server.listen(1)
print "Waiting..."
watch_client, client_info = server.accept()
print "Accepted connection from ", client_info
print dir(watch_client)
fd = None
try:
while True:
