def __init__(self, ob_ctx):
self.shutdown_mutex = Lock()
self.ob_ctx = ob_ctx
db = Obdb(ob_ctx.db_path, ob_ctx.disable_sqlite_crypt)
self.transport = CryptoTransportLayer(ob_ctx, db)
self.market = Market(self.transport, db)
self.upnp_mapper = None
Thread(target=reactor.run, args=(False, )).start()
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,
dict(transport=self.transport,
market_application=self,
db=db))]
# 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 = Obdb(ob_ctx.db_path, ob_ctx.disable_sqlite_crypt)
self.transport = CryptoTransportLayer(ob_ctx, db)
self.market = Market(self.transport, db)
self.upnp_mapper = None
print" alvaro init"
Thread(target=reactor.run, args=(False,)).start()
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,
dict(transport=self.transport, market_application=self, db=db))
]
# TODO: Move debug settings to configuration location
settings = dict(debug=True)
super(MarketApplication, self).__init__(handlers, **settings)
def __init__(self,
market_ip,
market_port,
market_id=1,
bm_user=None,
bm_pass=None,
bm_port=None,
seed_peers=None,
seed_mode=0,
dev_mode=False,
db_path='db/ob.db',
disable_sqlite_crypt=False):
if seed_peers is None:
seed_peers = []
db = Obdb(db_path, disable_sqlite_crypt)
self.transport = CryptoTransportLayer(market_ip, market_port,
market_id, db, bm_user, bm_pass,
bm_port, seed_mode, dev_mode)
self.market = Market(self.transport, db)
# UNUSED
# def post_joined():
# self.transport.dht._refreshNode()
# self.market.republish_contracts()
peers = seed_peers if seed_mode == 0 else []
self.transport.join_network(peers)
Thread(target=reactor.run, args=(False, )).start()
handlers = [(r"/", MainHandler), (r"/main", MainHandler),
(r"/html/(.*)", OpenBazaarStaticHandler, {
'path': './html'
}),
(r"/ws", WebSocketHandler,
dict(transport=self.transport,
market_application=self,
db=db))]
# TODO: Move debug settings to configuration location
settings = dict(debug=True)
tornado.web.Application.__init__(self, handlers, **settings)
def __init__(self, market_ip, market_port, market_id=1,
bm_user=None, bm_pass=None, bm_port=None, seed_peers=None,
seed_mode=0, dev_mode=False, db_path='db/ob.db', disable_sqlite_crypt=False, disable_ip_update=False):
if seed_peers is None:
seed_peers = []
db = Obdb(db_path, disable_sqlite_crypt)
self.transport = CryptoTransportLayer(market_ip,
market_port,
market_id,
db,
bm_user,
bm_pass,
bm_port,
seed_mode,
dev_mode,
disable_ip_update)
self.market = Market(self.transport, db)
# UNUSED
# def post_joined():
# self.transport.dht._refreshNode()
# self.market.republish_contracts()
peers = seed_peers if seed_mode == 0 else []
self.transport.join_network(peers)
Thread(target=reactor.run, args=(False,)).start()
handlers = [
(r"/", MainHandler),
(r"/main", MainHandler),
(r"/html/(.*)", OpenBazaarStaticHandler, {'path': './html'}),
(r"/ws", WebSocketHandler,
dict(transport=self.transport, market_application=self, db=db))
]
# TODO: Move debug settings to configuration location
settings = dict(debug=True)
tornado.web.Application.__init__(self, handlers, **settings)
class MarketApplication(tornado.web.Application):
def __init__(self, market_ip, market_port, market_id=1,
bm_user=None, bm_pass=None, bm_port=None, seed_peers=[],
seed_mode=0, dev_mode=False, db_path='db/ob.db'):
db = Obdb(db_path)
self.transport = CryptoTransportLayer(market_ip,
market_port,
market_id,
db,
bm_user,
bm_pass,
bm_port,
seed_mode,
dev_mode)
self.market = Market(self.transport, db)
def post_joined():
self.transport.dht._refreshNode()
self.market.republish_contracts()
peers = seed_peers if seed_mode == 0 else []
self.transport.join_network(peers)
Thread(target=reactor.run, args=(False,)).start()
handlers = [
(r"/", MainHandler),
(r"/main", MainHandler),
(r"/html/(.*)", OpenBazaarStaticHandler, {'path': './html'}),
(r"/ws", WebSocketHandler,
dict(transport=self.transport, market_application=self, db=db))
]
# TODO: Move debug settings to configuration location
settings = dict(debug=True)
tornado.web.Application.__init__(self, handlers, **settings)
def get_transport(self):
return self.transport
def setup_upnp_port_mappings(self, http_port, p2p_port):
upnp.PortMapper.DEBUG = False
print "Setting up UPnP Port Map Entry..."
# TODO: Add some setting whether or not to use UPnP
# if Settings.get(Settings.USE_UPNP_PORT_MAPPINGS):
self.upnp_mapper = upnp.PortMapper()
# TODO: Add some setting whether or not to clean all previous port
# mappings left behind by us
# if Settings.get(Settings.CLEAN_UPNP_PORT_MAPPINGS_ON_START):
# upnp_mapper.cleanMyMappings()
# for now let's always clean mappings every time.
self.upnp_mapper.clean_my_mappings()
# result_http_port_mapping = self.upnp_mapper.add_port_mapping(http_port,
# http_port)
# print ("UPnP HTTP Port Map configuration done (%s -> %s) => %s" %
# (str(http_port), str(http_port), str(result_http_port_mapping)))
result_tcp_p2p_mapping = self.upnp_mapper.add_port_mapping(p2p_port,
p2p_port)
print ("UPnP TCP P2P Port Map configuration done (%s -> %s) => %s" %
(str(p2p_port), str(p2p_port), str(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 (%s -> %s) => %s" %
(str(p2p_port), str(p2p_port), str(result_udp_p2p_mapping)))
result = result_tcp_p2p_mapping and result_udp_p2p_mapping
if not result:
print("Warning: UPnP was not setup correctly. Try doing a port forward on %s and start the node again with -j" % p2p_port)
return result
def cleanup_upnp_port_mapping(self):
try:
if self.upnp_mapper is not None:
print "Cleaning UPnP Port Mapping -> ", \
self.upnp_mapper.clean_my_mappings()
except AttributeError:
print "[openbazaar] MarketApplication.clean_upnp_port_mapping() failed!"
pass
def shutdown(self, x=None, y=None):
print "MarketApplication.shutdown!"
locallogger = logging.getLogger('[%s] %s' % (self.market.market_id, 'root'))
locallogger.info("Received TERMINATE, exiting...")
# application.get_transport().broadcast_goodbye()
self.cleanup_upnp_port_mapping()
tornado.ioloop.IOLoop.instance().stop()
self.transport.shutdown()
os._exit(0)
class MarketApplication(tornado.web.Application):
def __init__(self, ob_ctx):
self.shutdown_mutex = Lock()
self.ob_ctx = ob_ctx
db = Obdb(ob_ctx.db_path, ob_ctx.disable_sqlite_crypt)
self.transport = CryptoTransportLayer(ob_ctx, db)
self.market = Market(self.transport, db)
self.upnp_mapper = None
print" alvaro init"
Thread(target=reactor.run, args=(False,)).start()
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,
dict(transport=self.transport, market_application=self, db=db))
]
# 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"
print "alvaro"
def get_transport(self):
return self.transport
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."
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...")
self.cleanup_upnp_port_mapping()
tornado.ioloop.IOLoop.instance().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 = Obdb(ob_ctx.db_path, ob_ctx.disable_sqlite_crypt)
self.transport = CryptoTransportLayer(ob_ctx, db)
self.market = Market(self.transport, db)
self.upnp_mapper = None
Thread(target=reactor.run, args=(False, )).start()
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,
dict(transport=self.transport,
market_application=self,
db=db))]
# 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 get_transport(self):
return self.transport
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."
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...")
self.cleanup_upnp_port_mapping()
tornado.ioloop.IOLoop.instance().stop()
self.transport.shutdown()
self.shutdown_mutex.release()
os._exit(0)
class MarketApplication(tornado.web.Application):
def __init__(self, market_ip, market_port, market_id=1,
bm_user=None, bm_pass=None, bm_port=None, seed_peers=None,
seed_mode=0, dev_mode=False, db_path='db/ob.db', disable_sqlite_crypt=False, disable_ip_update=False):
if seed_peers is None:
seed_peers = []
db = Obdb(db_path, disable_sqlite_crypt)
self.transport = CryptoTransportLayer(market_ip,
market_port,
market_id,
db,
bm_user,
bm_pass,
bm_port,
seed_mode,
dev_mode,
disable_ip_update)
self.market = Market(self.transport, db)
# UNUSED
# def post_joined():
# self.transport.dht._refreshNode()
# self.market.republish_contracts()
peers = seed_peers if seed_mode == 0 else []
self.transport.join_network(peers)
Thread(target=reactor.run, args=(False,)).start()
handlers = [
(r"/", MainHandler),
(r"/main", MainHandler),
(r"/html/(.*)", OpenBazaarStaticHandler, {'path': './html'}),
(r"/ws", WebSocketHandler,
dict(transport=self.transport, market_application=self, db=db))
]
# TODO: Move debug settings to configuration location
settings = dict(debug=True)
tornado.web.Application.__init__(self, handlers, **settings)
def get_transport(self):
return self.transport
def setup_upnp_port_mappings(self, http_port, p2p_port):
upnp.PortMapper.DEBUG = False
print "Setting up UPnP Port Map Entry..."
# TODO: Add some setting whether or not to use UPnP
# if Settings.get(Settings.USE_UPNP_PORT_MAPPINGS):
self.upnp_mapper = upnp.PortMapper()
# TODO: Add some setting whether or not to clean all previous port
# mappings left behind by us
# if Settings.get(Settings.CLEAN_UPNP_PORT_MAPPINGS_ON_START):
# upnp_mapper.cleanMyMappings()
# for now let's always clean mappings every time.
self.upnp_mapper.clean_my_mappings(p2p_port)
# result_http_port_mapping = self.upnp_mapper.add_port_mapping(http_port,
# http_port)
# print ("UPnP HTTP Port Map configuration done (%s -> %s) => %s" %
# (str(http_port), str(http_port), str(result_http_port_mapping)))
result_tcp_p2p_mapping = self.upnp_mapper.add_port_mapping(p2p_port,
p2p_port)
print ("UPnP TCP P2P Port Map configuration done (%s -> %s) => %s" %
(str(p2p_port), str(p2p_port), str(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 (%s -> %s) => %s" %
(str(p2p_port), str(p2p_port), str(result_udp_p2p_mapping)))
result = result_tcp_p2p_mapping and result_udp_p2p_mapping
if not result:
print "Warning: UPnP was not setup correctly. Try doing a port forward on %s and start the node again with -j" % p2p_port
return result
def cleanup_upnp_port_mapping(self):
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):
print "MarketApplication.shutdown!"
locallogger = logging.getLogger(
'[%s] %s' % (self.market.market_id, 'root')
)
locallogger.info("Received TERMINATE, exiting...")
# application.get_transport().broadcast_goodbye()
self.cleanup_upnp_port_mapping()
tornado.ioloop.IOLoop.instance().stop()
self.transport.shutdown()
os._exit(0)
