mimetype = "text/xml" stringio = StringIO.StringIO() stringio.write(s) stringio.seek(0) response = Message() response.compose(code="200", reason="Ok", mimetype=mimetype, body=stringio) stream.send_response(request, response) CONFIG.register_defaults({ "rendezvous.server.address": "0.0.0.0", "rendezvous.server.daemonize": True, "rendezvous.server.ports": "9773,8080", "rendezvous.server.update_uri": "http://www.neubot.org/download", "rendezvous.server.update_version": common.VERSION, "rendezvous.geoip_wrapper.country_database": "/usr/local/share/GeoIP/GeoIP.dat", "rendezvous.server.default": "master.neubot.org", }) def run(poller, conf): """ Load MaxMind database and register our child server """ GEOLOCATOR.open_or_die() LOG.info("This product includes GeoLite data created by MaxMind, " "available from <http://www.maxmind.com/>.") server = ServerRendezvous(None) server.configure(conf) HTTP_SERVER.register_child(server, "/rendezvous")
stream.attach(self, sock, nconf) self.connection_ready(stream) def connection_ready(self, stream): ''' Invoked when the connection is ready ''' def accept_failed(self, listener, exception): ''' Print a warning if accept() fails (often due to SSL) ''' logging.warning("ServerHTTP: accept() failed: %s", str(exception)) HTTP_SERVER = ServerHTTP(POLLER) CONFIG.register_defaults({ "http.server.address": "", "http.server.class": "", "http.server.mime": True, "http.server.ports": "8080,", "http.server.rootdir": "", "http.server.ssi": False, }) def main(args): ''' main() function of this module ''' CONFIG.register_descriptions({ "http.server.address": "Address to listen to", "http.server.class": "Use alternate ServerHTTP-like class", "http.server.mime": "Enable code that guess mime types", "http.server.ports": "List of ports to listen to", "http.server.rootdir": "Root directory for static pages", "http.server.ssi": "Enable server-side includes",
def send_complete(self): if self.kind == "echo": self.start_recv() return self.start_send(self.buffer) CONFIG.register_defaults({ # General variables "net.stream.certfile": "", "net.stream.ipv6": False, "net.stream.key": "", "net.stream.secure": False, "net.stream.server_side": False, "net.stream.rcvbuf": 0, "net.stream.sndbuf": 0, # For main() "net.stream.address": "127.0.0.1", "net.stream.chunk": 262144, "net.stream.clients": 1, "net.stream.daemonize": False, "net.stream.duration": 10, "net.stream.listen": False, "net.stream.port": 12345, "net.stream.proto": "", }) def main(args): CONFIG.register_descriptions({ # General variables "net.stream.certfile": "Set SSL certfile path",
sys.exit("This command runs under 'posix' only") import pwd import subprocess if __name__ == "__main__": sys.path.insert(0, ".") from neubot.config import CONFIG from neubot.log import LOG from neubot.main import common CONFIG.register_defaults({ "net.CA.basedir": "/etc/neubot", "net.CA.bits": 4096, "net.CA.cacert": "_cacert.pem", "net.CA.days": 1095, "net.CA.privkey": "_privkey.pem", }) def main(args): """ Generate private key and certificate file for Neubot server """ CONFIG.register_descriptions({ "net.CA.bits": "Set private key bits number", "net.CA.cacert": "Set certificate file path", "net.CA.days": "Set days before expire", "net.CA.privkey": "Set private key file path", }) common.main("net.CA", "generate test certificates", args)
mimetype="application/json") else: response.compose(code="404", reason="Not Found") stream.send_response(request, response) # # Register default values in the global scope so that # their variable names are always defined and the rules # for casting the types apply. # CONFIG.register_defaults({ "server.bittorrent": True, "server.daemonize": True, 'server.debug': False, "server.negotiate": True, "server.rendezvous": False, # Not needed on the random server "server.sapi": True, "server.speedtest": True, }) def main(args): """ Starts the server module """ # # Register descriptions in main() only so that # we don't advertise the name of knobs that aren't # relevant in the current context. # CONFIG.register_descriptions({ "server.bittorrent": "Start up BitTorrent test and negotiate server",
while self.streams: # # Override child Time-To-Connect (TTC) with our TTC # so for the child it's like it really performed the # connect(), not us. # self.child.rtts = self.rtts self.child.connection_ready(self.streams.popleft()) if justone: break CONFIG.register_defaults( { "speedtest.client.uri": "http://master.neubot.org/", "speedtest.client.nconn": 1, "speedtest.client.latency_tries": 10, } ) def main(args): """ Main function """ try: options, arguments = getopt.getopt(args[1:], "6A:fp:v") except getopt.error: sys.exit("usage: neubot speedtest [-6fv] [-A address] [-p port]") if arguments: sys.exit("usage: neubot speedtest [-6fv] [-A address] [-p port]") prefer_ipv6 = 0
# # You should have received a copy of the GNU General Public License # along with Neubot. If not, see <http://www.gnu.org/licenses/>. # """ Negotiate module """ from neubot.config import CONFIG from neubot.negotiate.server_speedtest import NEGOTIATE_SERVER_SPEEDTEST from neubot.negotiate.server_bittorrent import NEGOTIATE_SERVER_BITTORRENT from neubot.negotiate.server_raw import NEGOTIATE_SERVER_RAW from neubot.negotiate.server_skype import NEGOTIATE_SERVER_SKYPE from neubot.negotiate.server import NEGOTIATE_SERVER from neubot.http.server import HTTP_SERVER CONFIG.register_defaults({"negotiate.parallelism": 7, "negotiate.min_thresh": 32, "negotiate.max_thresh": 64}) def run(poller, conf): """ Start the negotiate server """ NEGOTIATE_SERVER.register_module("speedtest", NEGOTIATE_SERVER_SPEEDTEST) NEGOTIATE_SERVER.register_module("bittorrent", NEGOTIATE_SERVER_BITTORRENT) NEGOTIATE_SERVER.register_module("raw", NEGOTIATE_SERVER_RAW) NEGOTIATE_SERVER.register_module("skype", NEGOTIATE_SERVER_SKYPE) HTTP_SERVER.register_child(NEGOTIATE_SERVER, "/negotiate/") HTTP_SERVER.register_child(NEGOTIATE_SERVER, "/collect/") CONFIG.register_descriptions( {
''' Returns True if we are allowed to collect a result into the database, and False otherwise ''' if type(m) != types.DictType: # # XXX This is a shame therefore put the oops() and hope that # it does its moral suasion job as expected. # LOG.oops("TODO: please pass me a dictionary!", LOG.debug) m = m.__dict__ return (not utils.intify(m["privacy_informed"]) or utils.intify(m["privacy_can_collect"])) CONFIG.register_defaults({ 'privacy.init_informed': 0, 'privacy.init_can_collect': 0, 'privacy.init_can_share': 0, 'privacy.overwrite': 0, }) def main(args): ''' Will initialize privacy settings ''' CONFIG.register_descriptions({ 'privacy.init_informed': "You've read privacy policy", 'privacy.init_can_collect': 'We can collect your IP address', 'privacy.init_can_share': 'We can share your IP address', 'privacy.overwrite': 'Overwrite old settings', }) common.main('privacy', 'Initialize privacy settings', args)
body = marshal.marshal_object(obody, "application/json") mimetype = "application/json" else: body = compat.adhoc_marshaller(obody) mimetype = "text/xml" response = Message() response.compose(code="200", reason="Ok", mimetype=mimetype, body=body) stream.send_response(request, response) CONFIG.register_defaults( { "rendezvous.server.address": "", "rendezvous.server.ports": "9773,8080", "rendezvous.server.update_version": "0.4.15.6", "rendezvous.geoip_wrapper.country_database": "/usr/local/share/GeoIP/GeoIP.dat", "rendezvous.server.default": "master.neubot.org", } ) def run(): """ Load MaxMind database and register our child server """ GEOLOCATOR.open_or_die() logging.info("This product includes GeoLite data created by MaxMind, " "available from <http://www.maxmind.com/>.") server = ServerRendezvous(None) server.configure(CONFIG) HTTP_SERVER.register_child(server, "/rendezvous")
body = None if request.uri == "/speedtest/negotiate": body = FAKE_NEGOTIATION response.compose(code="200", reason="Ok", body=body) stream.send_response(request, response) else: response = Message() body = "500 Internal Server Error" response.compose(code="500", reason="Internal Server Error", body=body, mimetype="text/plain") stream.send_response(request, response) CONFIG.register_defaults({ "speedtest.server.address": "0.0.0.0", "speedtest.server.daemonize": True, "speedtest.server.port": "80", }) def main(args): common.main("speedtest.server", "Speedtest Test Server", args) conf = CONFIG.copy() server = ServerTest(POLLER) server.configure(conf) server.listen((conf["speedtest.server.address"], conf["speedtest.server.port"])) if conf["speedtest.server.daemonize"]:
m = marshal.unmarshal_object(s, "text/xml", compat.SpeedtestCollect) if privacy.collect_allowed(m): table_speedtest.insertxxx(DATABASE.connection(), m) response = Message() response.compose(code="200", reason="Ok") stream.send_response(request, response) def connection_lost(self, stream): TRACKER.unregister_connection(stream) NOTIFIER.publish(RENEGOTIATE) CONFIG.register_defaults({ "speedtest.negotiate.address": "0.0.0.0", "speedtest.negotiate.auth_only": True, "speedtest.negotiate.daemonize": True, "speedtest.negotiate.port": "80", }) def main(args): CONFIG.register_descriptions({ "speedtest.negotiate.address": "Address to listen to", "speedtest.negotiate.auth_only": "Enable doing tests for authorized clients only", "speedtest.negotiate.daemonize": "Enable going in background", "speedtest.negotiate.port": "Port to listen to", }) common.main("speedtest.negotiate", "Speedtest negotiation server", args) conf = CONFIG.copy()
STATE.update("test", "speedtest") else: STATE.update(self.state) LOG.start("* speedtest: %s" % self.state) elif self.state == "negotiate": LOG.start("* speedtest: %s" % self.state) self.measurer.start(self.state) while self.streams: self.child.connection_ready(self.streams.popleft()) if justone: break CONFIG.register_defaults({ "speedtest.client.uri": "http://neubot.blupixel.net/", "speedtest.client.nconn": 1, "speedtest.client.latency_tries": 10, }) def main(args): CONFIG.register_descriptions({ "speedtest.client.uri": "Base URI to connect to", "speedtest.client.nconn": "Number of concurrent connections to use", "speedtest.client.latency_tries": "Number of latency measurements", }) common.main("speedtest.client", "Speedtest client", args) conf = CONFIG.copy() client = ClientSpeedtest(POLLER) client.configure(conf)
# # You should have received a copy of the GNU General Public License # along with Neubot. If not, see <http://www.gnu.org/licenses/>. # ''' Negotiate module ''' from neubot.config import CONFIG from neubot.negotiate.server_speedtest import NEGOTIATE_SERVER_SPEEDTEST from neubot.negotiate.server_bittorrent import NEGOTIATE_SERVER_BITTORRENT from neubot.negotiate.server import NEGOTIATE_SERVER from neubot.http.server import HTTP_SERVER CONFIG.register_defaults({ 'negotiate.parallelism': 3, 'negotiate.min_thresh': 32, 'negotiate.max_thresh': 64, }) def run(poller, conf): ''' Start the negotiate server ''' NEGOTIATE_SERVER.register_module('speedtest', NEGOTIATE_SERVER_SPEEDTEST) NEGOTIATE_SERVER.register_module('bittorrent', NEGOTIATE_SERVER_BITTORRENT) HTTP_SERVER.register_child(NEGOTIATE_SERVER, '/negotiate/') HTTP_SERVER.register_child(NEGOTIATE_SERVER, '/collect/') CONFIG.register_descriptions({ 'negotiate.parallelism': 'Number of parallel tests', 'negotiate.min_thresh': 'Minimum trehshold for RED',
interval = CONFIG["agent.interval"] if not interval: if not self._interval: self._interval = 1380 + random.randrange(0, 240) interval = self._interval LOG.info("* Next rendezvous in %d seconds" % interval) fn = lambda *args, **kwargs: self.connect_uri() self._task = POLLER.sched(interval, fn) STATE.update("idle", publish=False) STATE.update("next_rendezvous", self._task.timestamp) CONFIG.register_defaults({"rendezvous.client.debug": False, "rendezvous.client.version": common.VERSION}) def main(args): CONFIG.register_descriptions( { "rendezvous.client.debug": "Do not perform any test", "rendezvous.client.version": "Set rendezvous client version", } ) common.main("rendezvous.client", "Rendezvous client", args) conf = CONFIG.copy() client = ClientRendezvous(POLLER)
t = dictionary["t"] if not type(t) == types.IntType and not type(t) == types.LongType: raise ValueError("Invalid type for current event time") if t < 0: raise ValueError("Invalid value for current event time") self.timestamp = t self.process_dictionary(dictionary) def process_dictionary(self, dictionary): octets = json.dumps(dictionary) sys.stdout.write(octets) sys.stdout.write("\n\n") CONFIG.register_defaults({ "api.client.address": "127.0.0.1", "api.client.port": "9774", }) def main(args): CONFIG.register_descriptions({ "api.client.address": "Set address to connect to", "api.client.port": "Set port to connect to", }) common.main("api.client", "Minimal client for JSON API", args) client = APIStateTracker(POLLER) client.configure(CONFIG.copy()) client.loop() if __name__ == "__main__":
response = Message() if method == "GET" and not stdout: fpath = uri.split("/")[-1] if os.path.exists(fpath): logging.error("* Local file already exists: %s", fpath) sys.exit(1) response.body = open(fpath, "wb") else: response.body = sys.stdout stream.send_request(request, response) CONFIG.register_defaults({ "http.client.class": "", "http.client.method": "GET", "http.client.stdout": False, "http.client.uri": "", }) def main(args): ''' main() of this module ''' CONFIG.register_descriptions({ "http.client.class": "Specify alternate ClientHTTP-like class", "http.client.method": "Specify alternate HTTP method", "http.client.stdout": "Enable writing response to stdout", "http.client.uri": "Specify URI to download from/upload to", }) common.main("http.client", "Simple Neubot HTTP client", args)
def recv_complete(self, octets): self.start_recv() if self.kind == "echo": self.start_send(octets) def send_complete(self): if self.kind == "echo": self.start_recv() return self.start_send(self.buffer) CONFIG.register_defaults({ "net.stream.certfile": "", "net.stream.ipv6": False, "net.stream.key": "", "net.stream.obfuscate": False, "net.stream.secure": False, "net.stream.server_side": False, "net.stream.rcvbuf": 0, "net.stream.sndbuf": 0, }) CONFIG.register_defaults({ "net.stream.address": "", "net.stream.chunk": 32768, "net.stream.clients": 1, "net.stream.daemonize": False, "net.stream.duration": 10, "net.stream.listen": False, "net.stream.port": 12345, "net.stream.proto": "", })