def send_request(p, action):
log.info(log_category, "event.subscribe.send_request %r, action: %r %r", p, action, path)
if action == "subscribe":
timeout = service.timeout
if timeout == 0:
timeout = 1800
request = ["SUBSCRIBE %s HTTP/1.1" % path, "HOST: %s:%d" % (host, port), "TIMEOUT: Second-%d" % timeout]
service.event_connection = p
else:
request = ["UNSUBSCRIBE %s HTTP/1.1" % path, "HOST: %s:%d" % (host, port)]
if service.get_sid():
request.append("SID: %s" % service.get_sid())
else:
request.append("CALLBACK: <%s>" % myurl)
request.append("NT: upnp:event")
request.append("Date: %s" % time.strftime("%a, %d %b %Y %H:%M:%S GMT", time.gmtime()))
request.append("Content-Length: 0")
request.append("")
request.append("")
request = "\r\n".join(request)
log.debug(log_category, "event.subscribe.send_request %r %r", request, p)
try:
p.transport.writeSomeData(request)
except AttributeError:
log.info(log_category, "transport for event %r already gone", action)
def prepare_connection(service, action):
log.info(log_category, "event.subscribe.prepare_connection action: %r %r", action, service.event_connection)
if service.event_connection == None:
c = ClientCreator(reactor, EventProtocol, service=service, action=action)
log.info(log_category, "event.subscribe.prepare_connection: %r %r", host, port)
d = c.connectTCP(host, port)
d.addCallback(send_request, action=action)
d.addErrback(got_error, action)
# reactor.callLater(3, teardown_connection, c, d)
else:
d = defer.Deferred()
d.addCallback(send_request, action=action)
d.callback(service.event_connection)
# send_request(service.event_connection, action)
return d
def prepare_connection( service, action):
log.info(log_category, "event.subscribe.prepare_connection action: %r %r",
action, service.event_connection)
if service.event_connection == None:
c = ClientCreator(reactor, EventProtocol, service=service, action=action)
log.info(log_category, "event.subscribe.prepare_connection: %r %r",
host, port)
d = c.connectTCP(host, port)
d.addCallback(send_request, action=action)
d.addErrback(got_error, action)
#reactor.callLater(3, teardown_connection, c, d)
else:
d = defer.Deferred()
d.addCallback(send_request, action=action)
d.callback(service.event_connection)
#send_request(service.event_connection, action)
return d
def send_request(p,port_item):
request = ['NOTIFY %s HTTP/1.1' % path,
'HOST: %s:%d' % (host, port),
'SEQ: %d' % s['seq'],
'CONTENT-TYPE: text/xml;charset="utf-8"',
'SID: %s' % s['sid'],
'NTS: upnp:propchange',
'NT: upnp:event',
'Content-Length: %d' % len(xml),
'',
xml]
request = '\r\n'.join(request)
log.info(log_category, "send_notification.send_request to %r %r",
s['sid'], s['callback'])
log.debug(log_category, "request: %r", request)
s['seq'] += 1
if s['seq'] > 0xffffffff:
s['seq'] = 1
p.transport.write(request)
port_item.disconnect()
def send_request(p,port_item):
request = ['NOTIFY %s HTTP/1.1' % path,
'HOST: %s:%d' % (host, port),
'SEQ: %d' % s['seq'],
'CONTENT-TYPE: text/xml;charset="utf-8"',
'SID: %s' % s['sid'],
'NTS: upnp:propchange',
'NT: upnp:event',
'Content-Length: %d' % len(xml),
'',
xml]
request = '\r\n'.join(request)
log.info(log_category, "send_notification.send_request to %r %r",
s['sid'], s['callback'])
log.debug(log_category, "request: %r", request)
s['seq'] += 1
if s['seq'] > 0xffffffff:
s['seq'] = 1
p.transport.write(request)
port_item.disconnect()
def send_request(p, action):
log.info(log_category, "event.subscribe.send_request %r, action: %r %r",
p, action, service.get_event_sub_url())
_,_,event_path,_,_ = urlsplit(service.get_event_sub_url())
if action == 'subscribe':
timeout = service.timeout
if timeout == 0:
timeout = 1800
request = ["SUBSCRIBE %s HTTP/1.1" % event_path,
"HOST: %s:%d" % (host, port),
"TIMEOUT: Second-%d" % timeout,
]
service.event_connection = p
else:
request = ["UNSUBSCRIBE %s HTTP/1.1" % event_path,
"HOST: %s:%d" % (host, port),
]
if service.get_sid():
request.append("SID: %s" % service.get_sid())
else:
# XXX use address and port set in the coherence instance
#ip_address = p.transport.getHost().host
global hostname, web_server_port
#print hostname, web_server_port
url = 'http://%s:%d/events' % (hostname, web_server_port)
request.append("CALLBACK: <%s>" % url)
request.append("NT: upnp:event")
request.append('Date: %s' % datetimeToString())
request.append( "Content-Length: 0")
request.append( "")
request.append( "")
request = '\r\n'.join(request)
log.debug(log_category, "event.subscribe.send_request %r %r", request, p)
try:
p.transport.writeSomeData(request)
except AttributeError:
log.info(log_category, "transport for event %r already gone", action)
def send_request(p, port_item):
request = [
"NOTIFY %s HTTP/1.1" % path,
"HOST: %s:%d" % (host, port),
"SEQ: %d" % s["seq"],
'CONTENT-TYPE: text/xml;charset="utf-8"',
"SID: %s" % s["sid"],
"NTS: upnp:propchange",
"NT: upnp:event",
"Content-Length: %d" % len(xml),
"",
xml,
]
request = "\r\n".join(request)
log.info(log_category, "send_notification.send_request to %r %r", s["sid"], s["callback"])
log.debug(log_category, "request: %r", request)
s["seq"] += 1
if s["seq"] > 0xFFFFFFFF:
s["seq"] = 1
p.transport.write(request)
port_item.disconnect()
def send_request(p, action):
log.info(log_category, "event.subscribe.send_request %r, action: %r %r",
p, action, service.get_event_sub_url())
_, _, event_path, _, _ = urlsplit(service.get_event_sub_url())
if action == 'subscribe':
timeout = service.timeout
if timeout == 0:
timeout = 1800
request = ["SUBSCRIBE %s HTTP/1.1" % event_path,
"HOST: %s:%d" % (host, port),
"TIMEOUT: Second-%d" % timeout,
]
service.event_connection = p
else:
request = ["UNSUBSCRIBE %s HTTP/1.1" % event_path,
"HOST: %s:%d" % (host, port),
]
if service.get_sid():
request.append("SID: %s" % service.get_sid())
else:
# XXX use address and port set in the coherence instance
#ip_address = p.transport.getHost().host
global hostname, web_server_port
#print hostname, web_server_port
url = 'http://%s:%d/events' % (hostname, web_server_port)
request.append("CALLBACK: <%s>" % url)
request.append("NT: upnp:event")
request.append('Date: %s' % datetimeToString())
request.append("Content-Length: 0")
request.append("")
request.append("")
request = '\r\n'.join(request)
log.debug(log_category, "event.subscribe.send_request %r %r", request, p)
try:
p.transport.writeSomeData(request)
except AttributeError:
log.info(log_category, "transport for event %r already gone", action)
def teardown_connection(c, d):
log.info(log_category, "event.subscribe.teardown_connection")
del d
del c
def got_error(failure, action):
log.info(log_category, "error on %s request with %s" % (action, service.get_base_url()))
log.debug(log_category, failure)
def subscribe(service, action="subscribe"):
"""
send a subscribe/renewal/unsubscribe request to a service
return the device response
"""
log_category = Event.__module__
log.info(log_category, "event.subscribe, action: %r", action)
# _,host_port,path,_,_ = urlsplit(service.get_base_url())
_, host_port, path, _, _ = urlsplit(service.get_event_sub_url())
if host_port.find(":") != -1:
host, port = tuple(host_port.split(":"))
port = int(port)
else:
host = host_port
port = 80
def send_request(p, action):
log.info(log_category, "event.subscribe.send_request %r, action: %r %r", p, action, path)
if action == "subscribe":
timeout = service.timeout
if timeout == 0:
timeout = 1800
request = ["SUBSCRIBE %s HTTP/1.1" % path, "HOST: %s:%d" % (host, port), "TIMEOUT: Second-%d" % timeout]
service.event_connection = p
else:
request = ["UNSUBSCRIBE %s HTTP/1.1" % path, "HOST: %s:%d" % (host, port)]
if service.get_sid():
request.append("SID: %s" % service.get_sid())
else:
request.append("CALLBACK: <%s>" % myurl)
request.append("NT: upnp:event")
request.append("Date: %s" % time.strftime("%a, %d %b %Y %H:%M:%S GMT", time.gmtime()))
request.append("Content-Length: 0")
request.append("")
request.append("")
request = "\r\n".join(request)
log.debug(log_category, "event.subscribe.send_request %r %r", request, p)
try:
p.transport.writeSomeData(request)
except AttributeError:
log.info(log_category, "transport for event %r already gone", action)
# print "event.subscribe.send_request", d
# return d
def got_error(failure, action):
log.info(log_category, "error on %s request with %s" % (action, service.get_base_url()))
log.debug(log_category, failure)
def teardown_connection(c, d):
log.info(log_category, "event.subscribe.teardown_connection")
del d
del c
def prepare_connection(service, action):
log.info(log_category, "event.subscribe.prepare_connection action: %r %r", action, service.event_connection)
if service.event_connection == None:
c = ClientCreator(reactor, EventProtocol, service=service, action=action)
log.info(log_category, "event.subscribe.prepare_connection: %r %r", host, port)
d = c.connectTCP(host, port)
d.addCallback(send_request, action=action)
d.addErrback(got_error, action)
# reactor.callLater(3, teardown_connection, c, d)
else:
d = defer.Deferred()
d.addCallback(send_request, action=action)
d.callback(service.event_connection)
# send_request(service.event_connection, action)
return d
""" FIXME:
we need to find a way to be sure that our unsubscribe calls get through
on shutdown
reactor.addSystemEventTrigger( 'before', 'shutdown', prepare_connection, service, action)
"""
return prepare_connection(service, action)
def subscribe(service, action = 'subscribe'):
"""
send a subscribe/renewal/unsubscribe request to a service
return the device response
"""
log_category = "event_protocol"
log.info(log_category, "event.subscribe, action: %r", action)
_, host_port, path, _, _ = urlsplit(service.get_base_url())
if host_port.find(':') != -1:
host, port = tuple(host_port.split(':'))
port = int(port)
else:
host = host_port
port = 80
def send_request(p, action):
log.info(log_category, "event.subscribe.send_request %r, action: %r %r",
p, action, service.get_event_sub_url())
_, _, event_path, _, _ = urlsplit(service.get_event_sub_url())
if action == 'subscribe':
timeout = service.timeout
if timeout == 0:
timeout = 1800
request = ["SUBSCRIBE %s HTTP/1.1" % event_path,
"HOST: %s:%d" % (host, port),
"TIMEOUT: Second-%d" % timeout,
]
service.event_connection = p
else:
request = ["UNSUBSCRIBE %s HTTP/1.1" % event_path,
"HOST: %s:%d" % (host, port),
]
if service.get_sid():
request.append("SID: %s" % service.get_sid())
else:
# XXX use address and port set in the coherence instance
#ip_address = p.transport.getHost().host
global hostname, web_server_port
#print hostname, web_server_port
url = 'http://%s:%d/events' % (hostname, web_server_port)
request.append("CALLBACK: <%s>" % url)
request.append("NT: upnp:event")
request.append('Date: %s' % datetimeToString())
request.append("Content-Length: 0")
request.append("")
request.append("")
request = '\r\n'.join(request)
log.debug(log_category, "event.subscribe.send_request %r %r", request, p)
try:
p.transport.writeSomeData(request)
except AttributeError:
log.info(log_category, "transport for event %r already gone", action)
# print "event.subscribe.send_request", d
#return d
def got_error(failure, action):
log.info(log_category, "error on %s request with %s" % (action, service.get_base_url()))
log.debug(log_category, failure)
def teardown_connection(c, d):
log.info(log_category, "event.subscribe.teardown_connection")
del d
del c
def prepare_connection(service, action):
log.info(log_category, "event.subscribe.prepare_connection action: %r %r",
action, service.event_connection)
if service.event_connection == None:
c = ClientCreator(reactor, EventProtocol, service = service, action = action)
log.info(log_category, "event.subscribe.prepare_connection: %r %r",
host, port)
d = c.connectTCP(host, port)
d.addCallback(send_request, action = action)
d.addErrback(got_error, action)
#reactor.callLater(3, teardown_connection, c, d)
else:
d = defer.Deferred()
d.addCallback(send_request, action = action)
d.callback(service.event_connection)
#send_request(service.event_connection, action)
return d
""" FIXME:
we need to find a way to be sure that our unsubscribe calls get through
on shutdown
reactor.addSystemEventTrigger( 'before', 'shutdown', prepare_connection, service, action)
"""
return prepare_connection(service, action)
def got_error(failure,port_item):
port_item.disconnect()
log.info(log_category, "error sending notification to %r %r",
s['sid'], s['callback'])
log.debug(log_category, failure)
def teardown_connection(c, d):
log.info(log_category, "event.subscribe.teardown_connection")
del d
del c
def got_error(failure, action):
log.info(log_category, "error on %s request with %s" % (action,service.get_base_url()))
log.debug(log_category, failure)
def got_error(failure, port_item):
port_item.disconnect()
log.info(log_category, "error sending notification to %r %r", s["sid"], s["callback"])
log.debug(log_category, failure)
def subscribe(service, action='subscribe'):
"""
send a subscribe/renewal/unsubscribe request to a service
return the device response
"""
log_category = "event_protocol"
log.info(log_category, "event.subscribe, action: %r", action)
_,host_port,path,_,_ = urlsplit(service.get_base_url())
if host_port.find(':') != -1:
host,port = tuple(host_port.split(':'))
port = int(port)
else:
host = host_port
port = 80
def send_request(p, action):
log.info(log_category, "event.subscribe.send_request %r, action: %r %r",
p, action, service.get_event_sub_url())
_,_,event_path,_,_ = urlsplit(service.get_event_sub_url())
if action == 'subscribe':
timeout = service.timeout
if timeout == 0:
timeout = 1800
request = ["SUBSCRIBE %s HTTP/1.1" % event_path,
"HOST: %s:%d" % (host, port),
"TIMEOUT: Second-%d" % timeout,
]
service.event_connection = p
else:
request = ["UNSUBSCRIBE %s HTTP/1.1" % event_path,
"HOST: %s:%d" % (host, port),
]
if service.get_sid():
request.append("SID: %s" % service.get_sid())
else:
# XXX use address and port set in the coherence instance
#ip_address = p.transport.getHost().host
global hostname, web_server_port
#print hostname, web_server_port
url = 'http://%s:%d/events' % (hostname, web_server_port)
request.append("CALLBACK: <%s>" % url)
request.append("NT: upnp:event")
request.append('Date: %s' % datetimeToString())
request.append( "Content-Length: 0")
request.append( "")
request.append( "")
request = '\r\n'.join(request)
log.debug(log_category, "event.subscribe.send_request %r %r", request, p)
try:
p.transport.writeSomeData(request)
except AttributeError:
log.info(log_category, "transport for event %r already gone", action)
# print "event.subscribe.send_request", d
#return d
def got_error(failure, action):
log.info(log_category, "error on %s request with %s" % (action,service.get_base_url()))
log.debug(log_category, failure)
def teardown_connection(c, d):
log.info(log_category, "event.subscribe.teardown_connection")
del d
del c
def prepare_connection( service, action):
log.info(log_category, "event.subscribe.prepare_connection action: %r %r",
action, service.event_connection)
if service.event_connection == None:
c = ClientCreator(reactor, EventProtocol, service=service, action=action)
log.info(log_category, "event.subscribe.prepare_connection: %r %r",
host, port)
d = c.connectTCP(host, port)
d.addCallback(send_request, action=action)
d.addErrback(got_error, action)
#reactor.callLater(3, teardown_connection, c, d)
else:
d = defer.Deferred()
d.addCallback(send_request, action=action)
d.callback(service.event_connection)
#send_request(service.event_connection, action)
return d
""" FIXME:
we need to find a way to be sure that our unsubscribe calls get through
on shutdown
reactor.addSystemEventTrigger( 'before', 'shutdown', prepare_connection, service, action)
"""
return prepare_connection(service, action)
