def __init__(self, ob_ctx):
self.shutdown_mutex = Lock()
self.ob_ctx = ob_ctx
self.loop = tornado.ioloop.IOLoop.instance()
db_connection = Obdb(ob_ctx.db_path, ob_ctx.disable_sqlite_crypt)
self.transport = CryptoTransportLayer(ob_ctx, db_connection)
self.market = Market(self.transport, db_connection)
self.upnp_mapper = None
Thread(target=reactor.run, args=(False, )).start()
# Mediator is used to route messages between NAT'd peers
#self.mediator = Mediator(self.ob_ctx.http_ip, self.ob_ctx.mediator_port)
peers = ob_ctx.seeds if not ob_ctx.seed_mode else []
self.transport.join_network(peers)
handlers = [(r"/", MainHandler), (r"/main", MainHandler),
(r"/html/(.*)", OpenBazaarStaticHandler, {
'path': './html'
}),
(r"/ws", WebSocketHandler, {
'transport': self.transport,
'market_application': self,
'db_connection': db_connection
})]
# TODO: Move debug settings to configuration location
settings = dict(debug=True)
super(MarketApplication, self).__init__(handlers, **settings)
def __init__(self, ob_ctx):
self.shutdown_mutex = Lock()
self.ob_ctx = ob_ctx
db_connection = Obdb(ob_ctx.db_path, ob_ctx.disable_sqlite_crypt)
self.transport = CryptoTransportLayer(ob_ctx, db_connection)
self.market = Market(self.transport, db_connection)
self.upnp_mapper = None
Thread(target=reactor.run, args=(False,)).start()
# Mediator is used to route messages between NAT'd peers
#self.mediator = Mediator(self.ob_ctx.http_ip, self.ob_ctx.mediator_port)
peers = ob_ctx.seeds if not ob_ctx.seed_mode else []
self.transport.join_network(peers)
handlers = [
(r"/", MainHandler),
(r"/main", MainHandler),
(r"/html/(.*)", OpenBazaarStaticHandler, {'path': './html'}),
(r"/ws", WebSocketHandler,
{
'transport': self.transport,
'market_application': self,
'db_connection': db_connection
})
]
# TODO: Move debug settings to configuration location
settings = dict(debug=True)
super(MarketApplication, self).__init__(handlers, **settings)
def create_layers(context, num_layers):
layers = []
for i in range(num_layers):
# dev_mode is True because otherwise the layer's ip is set to the
# public ip of the node
ob_ctx = OpenBazaarContext.create_default_instance()
ob_ctx.dev_mode = True
ob_ctx.server_ip = ip_address(i)
ob_ctx.server_port = PORT
db_path = get_db_path(i)
setup_db(db_path, ob_ctx.disable_sqlite_crypt)
layers.append(CryptoTransportLayer(ob_ctx, Obdb(db_path)))
context.layers = layers
def create_layers(context, num_layers):
layers = []
for i in range(num_layers):
db_path = get_db_path(i)
setup_db(db_path)
# dev_mode is True because otherwise the layer's ip is set to the
# public ip of the node
layers.append(
CryptoTransportLayer(ip_address(i),
port,
i,
Obdb(db_path),
dev_mode=True))
context.layers = layers
class MarketApplication(tornado.web.Application):
def __init__(self, ob_ctx):
self.shutdown_mutex = Lock()
self.ob_ctx = ob_ctx
self.loop = tornado.ioloop.IOLoop.instance()
db_connection = Obdb(ob_ctx.db_path, ob_ctx.disable_sqlite_crypt)
self.transport = CryptoTransportLayer(ob_ctx, db_connection)
self.market = Market(self.transport, db_connection)
self.upnp_mapper = None
Thread(target=reactor.run, args=(False, )).start()
# Mediator is used to route messages between NAT'd peers
#self.mediator = Mediator(self.ob_ctx.http_ip, self.ob_ctx.mediator_port)
peers = ob_ctx.seeds if not ob_ctx.seed_mode else []
self.transport.join_network(peers)
handlers = [(r"/", MainHandler), (r"/main", MainHandler),
(r"/html/(.*)", OpenBazaarStaticHandler, {
'path': './html'
}),
(r"/ws", WebSocketHandler, {
'transport': self.transport,
'market_application': self,
'db_connection': db_connection
})]
# TODO: Move debug settings to configuration location
settings = dict(debug=True)
super(MarketApplication, self).__init__(handlers, **settings)
def start_app(self):
# If self.ob_ctx.http_port is 0, the kernel is queried for a port.
sockets = tornado.netutil.bind_sockets(self.ob_ctx.http_port,
address=self.ob_ctx.http_ip)
server = tornado.httpserver.HTTPServer(self)
server.add_sockets(sockets)
self.ob_ctx.http_port = sockets[0].getsockname()[1]
if not self.ob_ctx.disable_upnp:
self.setup_upnp_port_mappings(self.ob_ctx.server_port)
else:
print "MarketApplication.start_app(): Disabling upnp setup"
def setup_upnp_port_mappings(self, p2p_port):
result = False
if not self.ob_ctx.disable_upnp:
upnp.PortMapper.DEBUG = False
print "Setting up UPnP Port Map Entry..."
self.upnp_mapper = upnp.PortMapper()
self.upnp_mapper.clean_my_mappings(p2p_port)
result_tcp_p2p_mapping = self.upnp_mapper.add_port_mapping(
p2p_port, p2p_port)
print "UPnP TCP P2P Port Map configuration done ",
print "(%s -> %s) => %s" % (p2p_port, p2p_port,
result_tcp_p2p_mapping)
result_udp_p2p_mapping = self.upnp_mapper.add_port_mapping(
p2p_port, p2p_port, 'UDP')
print "UPnP UDP P2P Port Map configuration done ",
print "(%s -> %s) => %s" % (p2p_port, p2p_port,
result_udp_p2p_mapping)
result = result_tcp_p2p_mapping and result_udp_p2p_mapping
if not result:
print "Warning: UPnP was not setup correctly. ",
print "Ports could not be automatically mapped."
print "If you only see two or three stores, here are some tips:"
print "1. If you are using VPN, configure port forwarding or disable your VPN temporarily"
print "2. Configure your router to forward traffic from port",
print "%s for both TCP and UDP to your local port %s" % (
p2p_port, p2p_port)
return result
def cleanup_upnp_port_mapping(self):
if not self.ob_ctx.disable_upnp:
try:
if self.upnp_mapper is not None:
print "Cleaning UPnP Port Mapping -> ", \
self.upnp_mapper.clean_my_mappings(self.transport.port)
except AttributeError:
print(
"[openbazaar] "
"MarketApplication.clean_upnp_port_mapping() failed!")
def shutdown(self, x_param=None, y_param=None):
self.shutdown_mutex.acquire()
print "MarketApplication.shutdown!"
log = logging.getLogger('[%s] %s' % (self.market.market_id, 'root'))
log.info("Received TERMINATE, exiting...")
# Send goodbye message to connected peers
for peer in self.transport.dht.active_peers:
peer.send_raw(
json.dumps({
'type': 'goodbye',
'pubkey': self.transport.pubkey,
'senderGUID': self.transport.guid,
'hostname': self.transport.hostname,
'port': self.transport.port,
'senderNick': self.transport.nickname,
'avatar_url': self.transport.avatar_url,
'v': constants.VERSION
}))
self.cleanup_upnp_port_mapping()
self.loop.stop()
self.transport.shutdown()
self.shutdown_mutex.release()
os._exit(0)
class MarketApplication(tornado.web.Application):
def __init__(self, ob_ctx):
self.shutdown_mutex = Lock()
self.ob_ctx = ob_ctx
db_connection = Obdb(ob_ctx.db_path, ob_ctx.disable_sqlite_crypt)
self.transport = CryptoTransportLayer(ob_ctx, db_connection)
self.market = Market(self.transport, db_connection)
self.upnp_mapper = None
Thread(target=reactor.run, args=(False,)).start()
# Mediator is used to route messages between NAT'd peers
#self.mediator = Mediator(self.ob_ctx.http_ip, self.ob_ctx.mediator_port)
peers = ob_ctx.seeds if not ob_ctx.seed_mode else []
self.transport.join_network(peers)
handlers = [
(r"/", MainHandler),
(r"/main", MainHandler),
(r"/html/(.*)", OpenBazaarStaticHandler, {'path': './html'}),
(r"/ws", WebSocketHandler,
{
'transport': self.transport,
'market_application': self,
'db_connection': db_connection
})
]
# TODO: Move debug settings to configuration location
settings = dict(debug=True)
super(MarketApplication, self).__init__(handlers, **settings)
def start_app(self):
# If self.ob_ctx.http_port is 0, the kernel is queried for a port.
sockets = tornado.netutil.bind_sockets(
self.ob_ctx.http_port,
address=self.ob_ctx.http_ip
)
server = tornado.httpserver.HTTPServer(self)
server.add_sockets(sockets)
self.ob_ctx.http_port = sockets[0].getsockname()[1]
if not self.ob_ctx.disable_upnp:
self.setup_upnp_port_mappings(self.ob_ctx.server_port)
else:
print "MarketApplication.start_app(): Disabling upnp setup"
def setup_upnp_port_mappings(self, p2p_port):
result = False
if not self.ob_ctx.disable_upnp:
upnp.PortMapper.DEBUG = False
print "Setting up UPnP Port Map Entry..."
self.upnp_mapper = upnp.PortMapper()
self.upnp_mapper.clean_my_mappings(p2p_port)
result_tcp_p2p_mapping = self.upnp_mapper.add_port_mapping(
p2p_port, p2p_port
)
print "UPnP TCP P2P Port Map configuration done ",
print "(%s -> %s) => %s" % (
p2p_port, p2p_port, result_tcp_p2p_mapping
)
result_udp_p2p_mapping = self.upnp_mapper.add_port_mapping(
p2p_port, p2p_port, 'UDP'
)
print "UPnP UDP P2P Port Map configuration done ",
print "(%s -> %s) => %s" % (
p2p_port, p2p_port, result_udp_p2p_mapping
)
result = result_tcp_p2p_mapping and result_udp_p2p_mapping
if not result:
print "Warning: UPnP was not setup correctly. ",
print "Ports could not be automatically mapped."
print "If you only see two or three stores, here are some tips:"
print "1. If you are using VPN, configure port forwarding or disable your VPN temporarily"
print "2. Configure your router to forward traffic from port",
print "%s for both TCP and UDP to your local port %s" % (p2p_port, p2p_port)
return result
def cleanup_upnp_port_mapping(self):
if not self.ob_ctx.disable_upnp:
try:
if self.upnp_mapper is not None:
print "Cleaning UPnP Port Mapping -> ", \
self.upnp_mapper.clean_my_mappings(self.transport.port)
except AttributeError:
print (
"[openbazaar] "
"MarketApplication.clean_upnp_port_mapping() failed!"
)
def shutdown(self, x=None, y=None):
self.shutdown_mutex.acquire()
print "MarketApplication.shutdown!"
log = logging.getLogger(
'[%s] %s' % (self.market.market_id, 'root')
)
log.info("Received TERMINATE, exiting...")
# Send goodbye message to connected peers
for peer in self.transport.dht.active_peers:
peer.send_raw(
json.dumps({
'type': 'goodbye',
'pubkey': self.transport.pubkey,
'senderGUID': self.transport.guid,
'hostname': self.transport.hostname,
'port': self.transport.port,
'senderNick': self.transport.nickname,
'avatar_url': self.transport.avatar_url,
'v': constants.VERSION
})
)
self.cleanup_upnp_port_mapping()
tornado.ioloop.IOLoop.instance().stop()
self.transport.shutdown()
self.shutdown_mutex.release()
os._exit(0)
