Пример #1
0
    def __init__(self, pdfpath, cacheroot):
        self.pdf = Pdf(pdfpath)
        self.cacheroot = cacheroot
        if not os.path.exists(cacheroot):
            os.makedirs(cacheroot)

        File.__init__(self, pdfpath)
Пример #2
0
    def startService(self):

        factory = WebSocketServerFactory("ws://localhost:%d" % self.port, debug=self.debug)

        factory.protocol = EchoServerProtocol
        factory.setProtocolOptions(allowHixie76=True)  # needed if Hixie76 is to be supported

        # FIXME: Site.start/stopFactory should start/stop factories wrapped as Resources
        factory.startFactory()

        resource = WebSocketResource(factory)

        # we server static files under "/" ..
        webdir = os.path.abspath(pkg_resources.resource_filename("echows", "web"))
        root = File(webdir)

        # and our WebSocket server under "/ws"
        root.putChild("ws", resource)

        # both under one Twisted Web Site
        site = Site(root)
        site.protocol = HTTPChannelHixie76Aware  # needed if Hixie76 is to be supported

        self.site = site
        self.factory = factory

        self.listener = reactor.listenTCP(self.port, site)
Пример #3
0
 def requestAvatar(self, avatarId, mind, *interfaces):
     for iface in interfaces:
         if iface is resource.IResource:
             resc = File("/tmp")
             resc.realm = self
             return (resource.IResource, resc, lambda: None)
     raise NotImplementedError("Can't support that interface.")
    def setUp(self):
        from twisted.python import threadpool
        reactor.threadpool = threadpool.ThreadPool(0, 10)
        reactor.threadpool.start()

        class Hello(resource.Resource):
            isLeaf = True

            def render_GET(self, request):
                return "<html>Hello, world!</html>"

        self.src_path = tempfile.mkdtemp(suffix=".src")
        self.cache_path = tempfile.mkdtemp(suffix=".cache")
        self._resource = None

        self.createSrcFile("a", "content of a")

        src = File(self.src_path)
        src.putChild("hello", Hello())
        factory = Site(src)
        self.httpserver = reactor.listenTCP(0, factory)
        p = self.httpserver.getHost().port

        plugProps = {"properties": {"cache-size": CACHE_SIZE,
                                    "cache-dir": self.cache_path,
                                    "virtual-hostname": "localhost",
                                    "virtual-port": p}}

        self.plug = \
            file_provider.FileProviderHTTPCachedPlug(plugProps)

        self.stats = DummyStats()
        self.plug.startStatsUpdates(self.stats)

        return self.plug.start(None)
    def start(self):
        """ start websocket server """
        logger.info('start websocket server at %s', self._url)
        self._factory = MyWebSocketServerFactory(
            self._url,
            debug=self._debug
        )

        self._factory.protocol = MyWebSocketServerProtocol
        self._factory.setProtocolOptions(allowHixie76=True)

        self._resource = WebSocketResource(self._factory)

        # we server static files under "/" ..
        root = File('.')

        # and our WebSocket server under "/websocket"
        root.putChild('websocket', self._resource)

        # both under one Twisted Web Site
        site = Site(root)
        site.protocol = HTTPChannelHixie76Aware
        reactor.listenTCP(self._port, site)
        self._thread = threading.Thread(target=reactor.run, args=(False,))
        self._thread.start()
Пример #6
0
    def startService(self):

        factory = WebSocketServerFactory(u"ws://127.0.0.1:%d" % self.port, debug=self.debug)
        factory.protocol = DispatcherProtocol
        factory.protocol.core = self._core

        # FIXME: Site.start/stopFactory should start/stop factories wrapped as Resources
        factory.startFactory()

        resource = WebSocketResource(factory)

        # we server static files under "/" ..
        webdir = os.path.abspath(pkg_resources.resource_filename("leap.bitmask_core", "web"))
        root = File(webdir)

        # and our WebSocket server under "/ws"
        root.putChild(u"bitmask", resource)

        # both under one Twisted Web Site
        site = Site(root)

        self.site = site
        self.factory = factory

        self.listener = reactor.listenTCP(self.port, site)
Пример #7
0
def startWebServer(options, config):
    # Extract properties from config
    log_dir  = str(config["configuration"]["log_dir"])
    content  = str(config["configuration"]["content"])
    endpoint = str(config["configuration"]["endpoint"])
    host     = str(config["configuration"]["host"])
    port     = int(config["configuration"]["port"])

    # Setup logging
    logFileName = log_dir + os.sep + "launcherLog.log"
    formatting = '%(asctime)s:%(levelname)s:%(name)s:%(message)s'
    logging.basicConfig(level=logging.DEBUG, filename=logFileName, filemode='w', format=formatting)
    observer = log.PythonLoggingObserver()
    observer.start()
    if options.debug:
        console = logging.StreamHandler(sys.stdout)
        console.setLevel(logging.INFO)
        formatter = logging.Formatter(formatting)
        console.setFormatter(formatter)
        logging.getLogger('').addHandler(console)

    # Initialize web resource
    web_resource = File(content) if (len(content) > 0) else resource.Resource()

    # Attach launcher
    web_resource.putChild(endpoint, LauncherResource(options, config))
    site = server.Site(web_resource)
    reactor.listenTCP(port, site, interface=host)
    reactor.run()
Пример #8
0
def start_web(port=8080):
    root = File('./enocean_site')
    root.putChild('radio', RadioResource())
    site = Site(root)
    reactor.listenTCP(port, site)
    logging.info('HTTP server running on port '+str(port))
    return site
Пример #9
0
def main():
    config = ConfigParser.ConfigParser()
    config.read(os.path.expanduser('~/.b07'))
    api = b07.api.API(reactor,
                      config.get('ingress', 'email'),
                      config.get('ingress', 'password'))
    

    http_root = Redirect('https://localhost:{}/'.format(config.get('server', 'https_port')))
    http_factory = Site(http_root)
    http_endpoint = endpoints.serverFromString(reactor,
                                               'tcp:{}'.format(config.get('server', 'http_port')))
    http_endpoint.listen(http_factory)

    https_root = File(os.path.expanduser(config.get('server', 'web_root')))
    https_root.indexNames = ['index.html']
    https_factory = Site(https_root)
    https_endpoint = endpoints.serverFromString(reactor,
                                                'ssl:{}:privateKey={}:certKey={}'.format(config.get('server', 'https_port'),
                                                                                         os.path.expanduser(config.get('server', 'ssl_key')),
                                                                                         os.path.expanduser(config.get('server', 'ssl_cert'))))
    https_endpoint.listen(https_factory)

    wsfactory = Factory()
    wsfactory.protocol = WebSocketProtocol
    wss_endpoint = endpoints.serverFromString(reactor,
                                              'ssl:{}:privateKey={}:certKey={}'.format(config.get('server', 'wss_port'),
                                                                                       os.path.expanduser(config.get('server', 'ssl_key')),
                                                                                       os.path.expanduser(config.get('server', 'ssl_cert'))))
    wss_endpoint.listen(txws.WebSocketFactory(wsfactory))



    reactor.run()
    def download_zip(self, request, request_id):
        download = yield self.download_database.get_download(
            self.logger, request_id=request_id
        )
        assert download.completed

        self.logger.bind(
            request_id=request_id,
            file_number=download.file_number,
        ).emit("download")

        document_types = yield self.document_types.wait()
        path = download.build_zip(self.jinja_env, self.fernet, document_types)

        request.setHeader(
            "Content-Disposition",
            "attachment; filename={}-eFolder.zip".format(download.file_number)
        )

        resource = File(path, defaultType="application/zip")
        resource.isLeaf = True

        request.notifyFinish().addBoth(lambda *args, **kwargs: os.remove(path))

        returnValue(resource)
    def startService(self):

        factory = WebSocketServerFactory(u"ws://127.0.0.1:%d" % self.port)
        factory.protocol = EchoServerProtocol

        # FIXME: Site.start/stopFactory should start/stop factories wrapped as Resources
        factory.startFactory()

        resource = WebSocketResource(factory)

        # we server static files under "/" ..
        webdir = os.path.abspath(pkg_resources.resource_filename("echows", "web"))
        root = File(webdir)

        # and our WebSocket server under "/ws" (note that Twisted uses
        # bytes for URIs)
        root.putChild(b"ws", resource)

        # both under one Twisted Web Site
        site = Site(root)

        self.site = site
        self.factory = factory

        self.listener = reactor.listenTCP(self.port, site)
Пример #12
0
    def makeService(self, options):
        if not options["noisy-logging"]:
            protocol.Factory.noisy = False

        endpoint = twitterEndpoint(options["endpoint"])
        tickeryService = service.MultiService()
        cache = TickeryCache(options["cache-dir"], options["restore-add-queue"], int(options["queue-width"]), endpoint)
        cache.setServiceParent(tickeryService)

        root = File("tickery/www/output")
        root.putChild("tickery", RegularService(cache, endpoint))
        root.putChild(defaults.TICKERY_CALLBACK_CHILD, callback.Callback(cache))

        adminRoot = File("tickery/admin/output")
        adminRoot.putChild("tickery", AdminService(cache))
        root.putChild("admin", adminRoot)

        factory = server.Site(root)
        if options["promiscuous"]:
            kw = {}
        else:
            kw = {"interface": "localhost"}
        tickeryServer = internet.TCPServer(int(options["port"]), factory, **kw)
        tickeryServer.setServiceParent(tickeryService)

        return tickeryService
Пример #13
0
def main(argv):
    from twisted.python import log
    from twisted.web.server import Site
    from twisted.web.static import File
    from twisted.internet import reactor
    from twisted.python import log

    observer = log.PythonLoggingObserver('twisted')
    log.startLoggingWithObserver(observer.emit, setStdout=False)

    static_dir = os.path.abspath('.')
    logging.info("registering static folder %r on /" % static_dir)
    root = File(static_dir)

    wr = TwistedWebResource(soap11_application)
    logging.info("registering %r on /%s" % (wr, url))
    root.putChild(url, wr)

    site = Site(root)

    if port[0] == 0:
        port[0] = get_open_port()
    reactor.listenTCP(port[0], site)
    logging.info("listening on: %s:%d" % (host,port))

    return reactor.run()
Пример #14
0
class Insist(Resource):
    isLeaf = True

    def __init__(self, cacheloc):
        self.cacheloc = cacheloc
        self.cachefile = None
        if os.path.exists(cacheloc):
            self.cachefile = File(cacheloc)
        self.reqs_waiting = []
        self.started = False
        Resource.__init__(self)

    def render_GET(self, req):
        # Check if someone else has created the file somehow
        if self.cachefile is None and os.path.exists(self.cacheloc):
            self.cachefile = File(self.cacheloc)
        # Check if someone else has *deleted* the file
        elif self.cachefile is not None and not os.path.exists(self.cacheloc):
            self.cachefile = None

        if self.cachefile is not None:
            return self.cachefile.render_GET(req)
        else:
            self.reqs_waiting.append(req)
            req.notifyFinish().addErrback(
                self._nevermind, req)
            if not self.started:
                self.started = True
                reactor.callInThread(self.desist)
            return NOT_DONE_YET

    def _nevermind(self, _err, req):
        self.reqs_waiting.remove(req)

    def desist(self):
        self.serialize_computation(self.cacheloc)
        reactor.callFromThread(self.resist)

    def _get_mime(self):
        return mimetypes.guess_type(self.cacheloc)[0]

    def resist(self):
        if not os.path.exists(self.cacheloc):
            # Error!
            print "%s does not exist - rendering fail!" % (self.cacheloc)
            for req in self.reqs_waiting:
                req.headers["Content-Type"] = "text/plain"
                req.write("cyst error")
                req.finish()
            return

        self.cachefile = File(self.cacheloc)

        # Send content to all interested parties
        for req in self.reqs_waiting:
            self.cachefile.render(req)

    def serialize_computation(self, outpath):
        raise NotImplemented
Пример #15
0
 def getChild(self, path, request):
    resource = File.getChild(self, path, request)
    for pat, repl in self._virtualLinks.iteritems():
       newPath = pat.sub(repl, path)
       if newPath != path:
          resource = File.getChild(self, newPath, request)
          break
    return resource
Пример #16
0
 def __init__(self, feederName, lockCamera, lockSensor):
     threading.Thread.__init__(self)
     feederName = feederName
     res = File('/home/pi/PiFeed/src/')
     res.putChild('', res)
     factory = Site(res)
     reactor.listenTCP(8000, factory)
     print('%s: twisted web server started' % (feederName))
Пример #17
0
def setup(scope, port=21000):
    MainHandler.scope = scope
    MainHandler.setup()
    global root
    root = File(".")
    root.putChild('_pyreg',File(os.path.dirname(__file__)+'/_pyreg'))
    site = WebSocketSite(root)
    site.addHandler("/ws/websocket", MainHandler)
    reactor.listenTCP(port, site)
Пример #18
0
 def __init__(self, service):
     pagedir = os.getcwd() + "/www"
     timeout = 60*60*12
     root = File(pagedir)
     dbres = Uploader()
     root.putChild("upload", dbres)
     root.childNotFound = File(pagedir+"/404.html")
     server.Site.__init__(self, root, logPath=None, timeout=timeout)
     self.service = service
Пример #19
0
    def getChild(self, uid, req):
        out_dir = self.transcriber.out_dir(uid)
        trans_ctrl = File(out_dir)

        # Add a Status endpoint to the file
        trans_status = TranscriptionStatus(self.transcriber.get_status(uid))
        trans_ctrl.putChild("status.json", trans_status)
        
        return trans_ctrl
 def getChild(self, name, request):
     #make source media available via oshash
     if request.path.startswith('/get/'):
         oshash = request.path.split('/')[-1]
         for path in self.client.path(oshash):
             if os.path.exists(path):
                 f = File(path, 'application/octet-stream')
                 f.isLeaf = True
                 return f
     return self
Пример #21
0
def runatomix():
    log.startLogging(stdout)
    factory  = WebSocketServerFactory(u"ws://127.0.0.1:8080")
    factory.protocol = WebServerProtocol
    resource = WebSocketResource(factory)
    root = File(".")
    root.putChild(u"ws", resource)
    site = Site(root)
    reactor.listenTCP(8080, site)
    reactor.run()
Пример #22
0
 def getChild(self, name, request):
     versionString = 'phoenix/%s' % self.core.VERSION
     request.setHeader('Server', versionString)
     if request.method == 'POST' and request.path == '/':
         return self
     else:
         docroot = os.path.join(self.core.basedir, 'www')
         root = File(self.core.config.get('web', 'root', str, docroot))
         root.processors = {'.rpy': script.ResourceScript}
         return root.getChild(name, request)
Пример #23
0
def setup():
  log_handler, log_buffer = setupLogging()

  status = monitor.status.Status()

  # Create our global shared status. Sort of a hard coded file adapter.
  config_file = os.path.join(BASE_DIR, 'server.json')
  with open(config_file, 'r') as f:
    status.set('status://server', json.load(f))

  # Setup the normal adapters.
  setupAdapters(status)

  # Create the manager for performing actions.
  action_manager = monitor.actions.ActionManager(status)

  # Instantiating the engine sets up the deferreds needed to keep it running.
  monitor.rules_engine.RulesEngine(status, action_manager)

  # Assemble the factory for our web server.
  # Serve the standard static web content, overlaid with our dynamic content
  root = File("./static")
  root.putChild("button", monitor.web_resources.Button(status))
  root.putChild("log", monitor.web_resources.Log(log_handler, log_buffer))
  root.putChild("restart", monitor.web_resources.Restart(status))
  root.putChild("status", monitor.web_resources.Status(status))

  reactor.listenTCP(status.get('status://server/port', 8080),
                    Site(root))
 def run(self):
     task.LoopingCall(self.status_check).start(0.5)
     root = File('www')
     root.putChild('st', StatusHandler(self))
     root.putChild('upd', self.updateHandler)
     root.putChild('cfg', ConfigHandler(self))
     root.putChild('upt', UptimeHandler(self))
     
     if self.config['config']['use_auth']:
         clk = ClickHandler(self)
         args={self.config['site']['username']:self.config['site']['password']}
         checker = checkers.InMemoryUsernamePasswordDatabaseDontUse(**args)
         realm = HttpPasswordRealm(clk)
         p = portal.Portal(realm, [checker])
         credentialFactory = BasicCredentialFactory("Garage Door Controller")
         protected_resource = HTTPAuthSessionWrapper(p, [credentialFactory])
         root.putChild('clk', protected_resource)
     else:
         root.putChild('clk', ClickHandler(self))
     
     site = server.Site(root)
     
     if not self.get_config_with_default(self.config['config'], 'use_https', False):
         reactor.listenTCP(self.config['site']['port'], site)  # @UndefinedVariable
         reactor.run()  # @UndefinedVariable
     else:
         sslContext = ssl.DefaultOpenSSLContextFactory(self.config['site']['ssl_key'], self.config['site']['ssl_cert'])
         reactor.listenSSL(self.config['site']['port_secure'], site, sslContext)  # @UndefinedVariable
         reactor.run()  # @UndefinedVariable
Пример #25
0
 def __init__(self, bucket, path, defaultType="text/html", ignoredExts=(),
              registry=None, allowExt=0, pwdic=None):
     # print "Instantiating WebDAV instance:", path
     File.__init__(self, path, defaultType=defaultType,
                   ignoredExts=ignoredExts, registry=registry,
                   allowExt=allowExt)
     self.path = path
     self.pwdic = pwdic
     self.s3 = boto.connect_s3()
     self.bucket = self.s3.get_bucket(bucket)
     self.mapper = S3ObjectMapper()
Пример #26
0
def secureSite(_environ=environ):
    """Builds the secure (HTTPS, port 443) site.

    """
    root = File(_environ["STATIC_PATH"])
    root.putChild("subscribe", SubscribeResource("*****@*****.**"))

    site = Site(root)
    site.displayTracebacks = False
    site.requestFactory = _withHSTS(site.requestFactory)
    return site
Пример #27
0
 def render_GET(self, request):
     since = request.getHeader('if-modified-since')
     if since:
         tsince = time.strptime(since.replace(" GMT", ""))
         tfrom = time.strptime(time.ctime(os.path.getmtime(self.path)))
         if tfrom > tsince:
             return File.render_GET(self, request)
         else:
             request.setResponseCode(304)
             return ""
     return File.render_GET(self, request)
Пример #28
0
def run(wf, port=9090):
    # web-control of a workflow
    datapath = os.path.join(os.path.dirname(__file__), "data")
    root = File(datapath)
    workflow_api = WorkflowAPI(wf)
    root.putChild("wf", workflow_api)
    site = Site(root)

    reactor.listenTCP(port, site, interface="0.0.0.0")
    print 'listening on port '+str(port)
    reactor.run()
Пример #29
0
    def resolve(self, path):
        if path == []:
            path = ['index.html']

        relative_path = os.path.join(*(['../..'] + path))
        filename = pkg_resources.resource_filename(__name__, relative_path)
        resource = File(filename)
        if not resource.exists():
            return False

        return ONCView(resource)
Пример #30
0
    def _file(self, path, type, encoding=None):
        """
        Construct a `twisted.web.static.File` customized to serve Yarrharr
        static assets.

        :param path: `twisted.internet.filepath.FilePath` instance
        :returns: `twisted.web.resource.IResource`
        """
        f = File(path.path)
        f.type = type
        f.encoding = encoding
        return f
Пример #31
0
 def root(request):
     return File(os.path.dirname(__file__))
Пример #32
0
    def _configure_named_resource(self, name, compress=False):
        """Build a resource map for a named resource

        Args:
            name (str): named resource: one of "client", "federation", etc
            compress (bool): whether to enable gzip compression for this
                resource

        Returns:
            dict[str, Resource]: map from path to HTTP resource
        """
        resources = {}
        if name == "client":
            client_resource = ClientRestResource(self)
            if compress:
                client_resource = gz_wrap(client_resource)

            resources.update(
                {
                    "/_matrix/client/api/v1": client_resource,
                    "/_matrix/client/r0": client_resource,
                    "/_matrix/client/unstable": client_resource,
                    "/_matrix/client/v2_alpha": client_resource,
                    "/_matrix/client/versions": client_resource,
                    "/.well-known/matrix/client": WellKnownResource(self),
                    "/_synapse/admin": AdminRestResource(self),
                }
            )

            if self.get_config().oidc_enabled:
                from synapse.rest.oidc import OIDCResource

                resources["/_synapse/oidc"] = OIDCResource(self)

            if self.get_config().saml2_enabled:
                from synapse.rest.saml2 import SAML2Resource

                resources["/_matrix/saml2"] = SAML2Resource(self)

            if self.get_config().threepid_behaviour_email == ThreepidBehaviour.LOCAL:
                from synapse.rest.synapse.client.password_reset import (
                    PasswordResetSubmitTokenResource,
                )

                resources[
                    "/_synapse/client/password_reset/email/submit_token"
                ] = PasswordResetSubmitTokenResource(self)

        if name == "consent":
            from synapse.rest.consent.consent_resource import ConsentResource

            consent_resource = ConsentResource(self)
            if compress:
                consent_resource = gz_wrap(consent_resource)
            resources.update({"/_matrix/consent": consent_resource})

        if name == "federation":
            resources.update({FEDERATION_PREFIX: TransportLayerServer(self)})

        if name == "openid":
            resources.update(
                {
                    FEDERATION_PREFIX: TransportLayerServer(
                        self, servlet_groups=["openid"]
                    )
                }
            )

        if name in ["static", "client"]:
            resources.update(
                {
                    STATIC_PREFIX: StaticResource(
                        os.path.join(os.path.dirname(synapse.__file__), "static")
                    )
                }
            )

        if name in ["media", "federation", "client"]:
            if self.get_config().enable_media_repo:
                media_repo = self.get_media_repository_resource()
                resources.update(
                    {MEDIA_PREFIX: media_repo, LEGACY_MEDIA_PREFIX: media_repo}
                )
            elif name == "media":
                raise ConfigError(
                    "'media' resource conflicts with enable_media_repo=False"
                )

        if name in ["keys", "federation"]:
            resources[SERVER_KEY_V2_PREFIX] = KeyApiV2Resource(self)

        if name == "webclient":
            webclient_loc = self.get_config().web_client_location

            if webclient_loc is None:
                logger.warning(
                    "Not enabling webclient resource, as web_client_location is unset."
                )
            elif webclient_loc.startswith("http://") or webclient_loc.startswith(
                "https://"
            ):
                resources[WEB_CLIENT_PREFIX] = RootRedirect(webclient_loc)
            else:
                logger.warning(
                    "Running webclient on the same domain is not recommended: "
                    "https://github.com/matrix-org/synapse#security-note - "
                    "after you move webclient to different host you can set "
                    "web_client_location to its full URL to enable redirection."
                )
                # GZip is disabled here due to
                # https://twistedmatrix.com/trac/ticket/7678
                resources[WEB_CLIENT_PREFIX] = File(webclient_loc)

        if name == "metrics" and self.get_config().enable_metrics:
            resources[METRICS_PREFIX] = MetricsResource(RegistryProxy)

        if name == "replication":
            resources[REPLICATION_PREFIX] = ReplicationRestResource(self)

        return resources
Пример #33
0
from twisted.internet import reactor
from twisted.web.server import Site
from twisted.web.static import File

resource = File('/var/www/mysite')
factory = Site(resource)
reactor.listenTCP(8000, factory)
reactor.run()
Пример #34
0
        log.startLogging(sys.stdout)
        debug = True
    else:
        debug = False

    wsPort = 9000

    # Our WebSocket server
    ##
    factory = WebSocketServerFactory(u"ws://127.0.0.1:%d" % wsPort,
                                     debug=debug,
                                     debugCodePaths=debug)

    factory.protocol = EchoServerProtocol
    listenWS(factory)

    # We need to start a "Flash Policy Server" on TCP/843
    # which Adobe Flash player will contact to check if
    # it is allowed to connect to the WebSocket port.
    ##
    flashPolicyFactory = FlashPolicyFactory()
    reactor.listenTCP(843, flashPolicyFactory)

    # Static Web server
    ##
    webdir = File("./web")
    web = Site(webdir)
    reactor.listenTCP(8080, web)

    reactor.run()
Пример #35
0
from twisted.web.server import Site
from twisted.web.static import File
from twisted.internet import reactor
from twisted.internet import endpoints

resource = File("./static")
factory = Site(resource)
endpoint = endpoints.TCP4ServerEndpoint(reactor, 8000)
endpoint.listen(factory)
reactor.run()
Пример #36
0
 def build_resource_for_static_content(self):
     # This is old and should go away: not going to bother adding gzip
     return File("static")
Пример #37
0
# Get PLC time
plcTime = PLCSystemTime(plc)
d = plcTime.get()


def onResult(data):
    print "PLC Time is", data
    return data


d.addCallback(onResult)
#plcTime.set(None) # Set PLC to current server time

# Start listening as HTTP server
root = File("www")
#root.putChild("membrane_insert", Membrane(plc))
root.putChild("events", EventSource(plc))
root.putChild("write", Write(plc))
root.putChild("read", Read(plc))
root.putChild("logger", Logger(plc))
root.putChild("membrane", Membrane())
root.putChild("product", Product())
root.putChild("chemical", Chemical())
root.putChild("bag-filter", BagFilter())

factory = Site(root)
reactor.listenTCP(8000, factory)
reactor.run()
exit()
Пример #38
0
def start_server(camera_type, simulate_pixhawk, port=8000):
    """
    Start the airborne server.
    
    Parameters
    ----------
    camera_type: string
        Camera type. Options: [canon (default), simlulation].
    port: int, optional(=8000)
        Port used by server.
    """

    #
    # Create the auvsi data folder.
    #
    if not os.path.exists(gs.AUVSI_BASE_FOLDER):
        os.makedirs(gs.AUVSI_BASE_FOLDER)

    #
    # Setup logging.
    #
    f = DailyLogFile('server.log', gs.AUVSI_BASE_FOLDER)
    log.startLogging(f)

    #
    # Initialize the data base.
    #
    DB.initDB()

    #
    # Initialize the imageprocessing module.
    #
    IM.initIM()

    #
    # Initialize the pixhawk module.
    #
    if not simulate_pixhawk:
        PH.initPixHawk()
    else:
        PH.initPixHawkSimulation()

    #
    # Create the camera object.
    #
    global camera
    if camera_type.lower() == 'canon':
        camera = CanonCamera()
    elif camera_type.lower() == 'simulation':
        camera = SimulationCamera()
    else:
        raise NotImplementedError(
            'Camera type {camera}, not supported.'.format(camera=camera_type))

    #
    # add a watcher on the images folder
    #
    fs = FileSystemWatcher(gs.IMAGES_FOLDER)
    fs.Start()

    #
    # Config the server
    #
    root = HTTPserverMain()
    root.putChild("images", File(gs.RESIZED_IMAGES_FOLDER))
    factory = Site(root)

    #
    # Startup the reactor.
    #
    reactor.listenTCP(port, factory)
    reactor.run()
Пример #39
0
 def static(self, request):
     return File(self.static_dir)
Пример #40
0
def server():
    root = File(sys.argv[1])
    factory = Site(root)
    reactor.listenTCP(PORT, factory)
    reactor.run()
Пример #41
0
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('-u',
                        '--url',
                        default='ws://localhost:9001',
                        help='Listen URL [default: %(default)s]')
    parser.add_argument(
        '-O',
        '--options',
        default=jsondict({'failByDrop': False}),
        type=jsondict,
        action='append',
        help='extra options (overwrites existing) [default: %(default)s]')

    parser.add_argument('-p', '--webport', default=9090, type=int)
    parser.add_argument('-i',
                        '--listen-interface',
                        default='localhost',
                        help='interface to listen on')
    parser.add_argument('-w', '--webdir', default='.')
    parser.add_argument('-d',
                        '--debug',
                        default=False,
                        action='store_true',
                        help='Debug Mode [default: %(default)s]')

    parser.add_argument('-o',
                        '--outdir',
                        default='./pages/results',
                        metavar='DIR',
                        help='Output Directory [default: %(default)s]')

    parser.add_argument('-c',
                        '--cases',
                        default=['*'],
                        nargs='+',
                        help='test cases [default: %(default)s]')
    parser.add_argument('-x',
                        '--exclude-cases',
                        default=[],
                        nargs='+',
                        help='test cases to exclude [default: %(default)s]')

    parser.add_argument('-l',
                        '--logfile',
                        type=argparse.FileType('w'),
                        default=sys.stdout,
                        help='logging file [default: stdout]')

    parser.add_argument(
        '-t',
        '--exit-timeout',
        metavar='SECONDS',
        default=None,
        type=float,
        help=
        'Will automatically exit after %(metavar)s seconds [default: %(default)s]'
    )

    args = parser.parse_args()

    spec = args.__dict__

    log.startLogging(args.logfile)

    ## fuzzing server
    fuzzer = FuzzingServerFactory(spec)
    listenWS(fuzzer, interface=args.listen_interface)

    ## web server
    webdir = File(args.webdir)
    web = Site(webdir)
    reactor.listenTCP(args.webport, web, interface=args.listen_interface)

    log.msg("Using Twisted reactor class %s" % str(reactor.__class__))

    if args.exit_timeout:

        def exit_callback():
            log.msg("Exiting due to timeout (--exit-timeout/-t)")
            reactor.fireSystemEvent('shutdown')
            #reactor.stop()
            sys.exit(12)

        reactor.callLater(args.exit_timeout, exit_callback)

    reactor.run()
Пример #42
0
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
#

"""
HTTP Static content site + dispatches
"""

from twisted.internet import reactor
from twisted.web.server import Site
from twisted.web.static import File

root = File("/var/www/html")
root.putChild("log", File("/var/log/syslog"))
root.putChild("doc", File("/usr/share/doc"))
reactor.listenTCP(8000, Site(root))
reactor.run()
Пример #43
0
def serve(port=8765,
          interface='0.0.0.0',
          installSignalHandlers=0,
          nthreads=4,
          ntranscriptionthreads=2,
          data_dir=get_datadir('webdata')):
    logging.info("SERVE %d, %s, %d", port, interface, installSignalHandlers)

    if not os.path.exists(data_dir):
        os.makedirs(data_dir)

    zip_dir = os.path.join(data_dir, 'zip')
    if not os.path.exists(zip_dir):
        os.makedirs(zip_dir)

    f = File(data_dir)

    f.putChild('', File(get_resource('www/index.html')))
    f.putChild('status.html', File(get_resource('www/status.html')))
    f.putChild('preloader.gif', File(get_resource('www/preloader.gif')))

    trans = Transcriber(data_dir,
                        nthreads=nthreads,
                        ntranscriptionthreads=ntranscriptionthreads)
    trans_ctrl = TranscriptionsController(trans)
    f.putChild('transcriptions', trans_ctrl)

    trans_zippr = TranscriptionZipper(zip_dir, trans)
    f.putChild('zip', trans_zippr)

    s = Site(f)
    logging.info("about to listen")
    reactor.listenTCP(port, s, interface=interface)
    logging.info("listening")

    reactor.run(installSignalHandlers=installSignalHandlers)
Пример #44
0
    def __init__(
        self,
        pool,
        ui_enabled,
        lua_enabled,
        lua_sandbox_enabled,
        lua_package_path,
        lua_sandbox_allowed_modules,
        max_timeout,
        argument_cache_max_entries,
        strict_lua_runner,
    ):
        Resource.__init__(self)
        self.argument_cache = ArgumentCache(argument_cache_max_entries)
        self.ui_enabled = ui_enabled
        self.lua_enabled = lua_enabled

        _args = pool, max_timeout, self.argument_cache
        self.putChild(b"render.html", RenderHtmlResource(*_args))
        self.putChild(b"render.png", RenderPngResource(*_args))
        self.putChild(b"render.jpeg", RenderJpegResource(*_args))
        self.putChild(b"render.json", RenderJsonResource(*_args))
        self.putChild(b"render.har", RenderHarResource(*_args))

        self.putChild(b"_debug", DebugResource(pool, self.argument_cache))
        self.putChild(b"_gc", ClearCachesResource(self.argument_cache))
        self.putChild(b"_ping", PingResource())

        # backwards compatibility
        self.putChild(b"debug",
                      DebugResource(pool, self.argument_cache, warn=True))

        if self.lua_enabled and ExecuteLuaScriptResource is not None:
            lua_kwargs = dict(
                pool=pool,
                sandboxed=lua_sandbox_enabled,
                lua_package_path=lua_package_path,
                lua_sandbox_allowed_modules=lua_sandbox_allowed_modules,
                max_timeout=max_timeout,
                argument_cache=self.argument_cache,
                strict=strict_lua_runner,
            )
            self.putChild(
                b"execute",
                ExecuteLuaScriptResource(implicit_main=False, **lua_kwargs))
            self.putChild(
                b"run",
                ExecuteLuaScriptResource(implicit_main=True, **lua_kwargs))

        if self.ui_enabled:
            root = os.path.dirname(__file__)
            ui = File(os.path.join(root, 'ui'))

            har_path = os.path.join(root, 'vendor', 'harviewer', 'webapp')
            ui.putChild(to_bytes(HARVIEWER_PATH), File(har_path))
            inspections_path = os.path.join(root, 'kernel', 'inspections')
            ui.putChild(b"inspections", File(inspections_path))
            examples_path = os.path.join(root, 'examples')
            ui.putChild(b"examples", File(examples_path))

            self.putChild(b"_ui", ui)
            self.putChild(
                DemoUI.PATH,
                DemoUI(pool=pool,
                       lua_enabled=self.lua_enabled,
                       max_timeout=max_timeout))
        self.max_timeout = max_timeout
Пример #45
0
    def _configure_named_resource(self, name, compress=False):
        """Build a resource map for a named resource

        Args:
            name (str): named resource: one of "client", "federation", etc
            compress (bool): whether to enable gzip compression for this
                resource

        Returns:
            dict[str, Resource]: map from path to HTTP resource
        """
        resources = {}
        if name == "client":
            client_resource = ClientRestResource(self)
            if compress:
                client_resource = gz_wrap(client_resource)

            resources.update({
                "/_matrix/client/api/v1": client_resource,
                "/_matrix/client/r0": client_resource,
                "/_matrix/client/unstable": client_resource,
                "/_matrix/client/v2_alpha": client_resource,
                "/_matrix/client/versions": client_resource,
            })

        if name == "consent":
            from synapse.rest.consent.consent_resource import ConsentResource
            consent_resource = ConsentResource(self)
            if compress:
                consent_resource = gz_wrap(consent_resource)
            resources.update({
                "/_matrix/consent": consent_resource,
            })

        if name == "federation":
            resources.update({
                FEDERATION_PREFIX: TransportLayerServer(self),
            })

        if name in ["static", "client"]:
            resources.update({
                STATIC_PREFIX:
                File(os.path.join(os.path.dirname(synapse.__file__),
                                  "static")),
            })

        if name in ["media", "federation", "client"]:
            if self.get_config().enable_media_repo:
                media_repo = self.get_media_repository_resource()
                resources.update({
                    MEDIA_PREFIX:
                    media_repo,
                    LEGACY_MEDIA_PREFIX:
                    media_repo,
                    CONTENT_REPO_PREFIX:
                    ContentRepoResource(self, self.config.uploads_path),
                })
            elif name == "media":
                raise ConfigError(
                    "'media' resource conflicts with enable_media_repo=False",
                )

        if name in ["keys", "federation"]:
            resources.update({
                SERVER_KEY_PREFIX: LocalKey(self),
                SERVER_KEY_V2_PREFIX: KeyApiV2Resource(self),
            })

        if name == "webclient":
            resources[WEB_CLIENT_PREFIX] = build_resource_for_web_client(self)

        if name == "metrics" and self.get_config().enable_metrics:
            resources[METRICS_PREFIX] = MetricsResource(RegistryProxy)

        if name == "replication":
            resources[REPLICATION_PREFIX] = ReplicationRestResource(self)

        return resources
Пример #46
0
    def run(self):
        task.LoopingCall(self.status_check).start(0.5)
        root = File('www')
        root.putChild('st', StatusHandler(self))
        root.putChild('upd', self.updateHandler)
        root.putChild('cfg', ConfigHandler(self))
        root.putChild('upt', UptimeHandler(self))

        if self.config['config']['use_auth']:
            clk = ClickHandler(self)
            args={self.config['site']['username']:self.config['site']['password']}
            checker = checkers.InMemoryUsernamePasswordDatabaseDontUse(**args)
            realm = HttpPasswordRealm(clk)
            p = portal.Portal(realm, [checker])
            credentialFactory = BasicCredentialFactory("Garage Door Controller")
            protected_resource = HTTPAuthSessionWrapper(p, [credentialFactory])
            root.putChild('clk', protected_resource)
            cla = CloseHandler(self)
            cla_args={self.config['site']['username']:self.config['site']['password']}
            cla_checker = checkers.InMemoryUsernamePasswordDatabaseDontUse(**cla_args)
            cla_realm = HttpPasswordRealm(cla)
            cla_p = portal.Portal(cla_realm, [cla_checker])
            credentialFactory = BasicCredentialFactory("Garage Door Controller")
            cla_protected_resource = HTTPAuthSessionWrapper(cla_p, [credentialFactory])
            root.putChild('cla', cla_protected_resource)
        else:
            root.putChild('clk', ClickHandler(self))
            root.putChild('cla', CloseHandler(self))

        if self.config['config']['allow_api']:
            root.putChild('api', APIHandler(self))

        site = server.Site(root)

        if not self.get_config_with_default(self.config['config'], 'use_https', False):
            reactor.listenTCP(self.config['site']['port'], site)  # @UndefinedVariable
            reactor.run()  # @UndefinedVariable
        else:
            sslContext = ssl.DefaultOpenSSLContextFactory(self.config['site']['ssl_key'], self.config['site']['ssl_cert'])
            reactor.listenSSL(self.config['site']['port_secure'], site, sslContext)  # @UndefinedVariable
            reactor.run()  # @UndefinedVariable
Пример #47
0
    if lighttype not in lightTypes:
        logging.error("{}: Type '{}' is unknown, valid would be {}".format(
            s, lighttype, list(lightTypes.keys())))
        continue
    options = {k: conf.get(s, k) for k in conf.options(s)}
    del options['type']

    try:
        logging.info("Start {}".format(s))
        l = lightTypes[lighttype].open(name=s, **options)
    except TypeError as e:  # When option name is not known
        logging.error("{}: {}".format(s, e))
        continue
    lights[s] = l

root = File("../website/")
interface = JSONAnswer(list(lights.keys()))
interface.putChild(b"status", TrafficLightWeb(lights['local_light']))
root.putChild(b"interface", interface)

for s in lights:
    # After init, dereference symbolic names
    lights[s].dereference(lights)
    # Finally add them to the web tree
    interface.putChild(bytes(s.encode('ascii')), TrafficLightWeb(lights[s]))
# root.putChild("auth", Authenticator())

factory = Site(root)
endpoint = endpoints.TCP4ServerEndpoint(reactor, port)
endpoint.listen(factory)
reactor.run()
Пример #48
0
    def __init__(self, pool, ui_enabled, lua_enabled, lua_sandbox_enabled,
                 lua_package_path, lua_sandbox_allowed_modules, max_timeout):
        Resource.__init__(self)
        self.ui_enabled = ui_enabled
        self.lua_enabled = lua_enabled
        self.putChild(b"render.html", RenderHtmlResource(pool, max_timeout))
        self.putChild(b"render.png", RenderPngResource(pool, max_timeout))
        self.putChild(b"render.jpeg", RenderJpegResource(pool, max_timeout))
        self.putChild(b"render.json", RenderJsonResource(pool, max_timeout))
        self.putChild(b"render.har", RenderHarResource(pool, max_timeout))

        self.putChild(b"_debug", DebugResource(pool))
        self.putChild(b"_gc", ClearCachesResource())
        self.putChild(b"_ping", PingResource())

        # backwards compatibility
        self.putChild(b"debug", DebugResource(pool, warn=True))

        if self.lua_enabled and ExecuteLuaScriptResource is not None:
            self.putChild(
                b"execute",
                ExecuteLuaScriptResource(
                    pool=pool,
                    sandboxed=lua_sandbox_enabled,
                    lua_package_path=lua_package_path,
                    lua_sandbox_allowed_modules=lua_sandbox_allowed_modules,
                    max_timeout=max_timeout))

        if self.ui_enabled:
            root = os.path.dirname(__file__)
            ui = File(os.path.join(root, 'ui'))

            har_path = os.path.join(root, 'vendor', 'harviewer', 'webapp')
            ui.putChild(b"harviewer", File(har_path))
            inspections_path = os.path.join(root, 'kernel', 'inspections')
            ui.putChild(b"inspections", File(inspections_path))
            examples_path = os.path.join(root, 'examples')
            ui.putChild(b"examples", File(examples_path))

            self.putChild(b"_ui", ui)
            self.putChild(
                DemoUI.PATH,
                DemoUI(pool=pool,
                       lua_enabled=self.lua_enabled,
                       max_timeout=max_timeout))
        self.max_timeout = max_timeout
Пример #49
0
from twisted.web.server import Site
from twisted.web.resource import Resource
from twisted.internet import reactor
from twisted.web.static import File
import sys

root = Resource()
root.putChild("", File(sys.argv[0]))
factory = Site(root)
reactor.listenTCP(8080, factory)
reactor.run()
Пример #50
0
    def render_GET(self, request):
        parsedURL = theURLparse.urlparse(request.uri.decode().replace(
            "//", "/"))  #scheme,netloc,path,query
        thisPath = parsedURL.path.replace("//", "/")
        root, ext = os.path.splitext(thisPath)
        if thisPath == "/" or thisPath == "":
            ext = ".py"
            filename = "/serverInfo.py"
            fileFolder = self.config['packageFolder'] + "/html/"
            fullPath = self.config['webServerRoot'] + fileFolder + filename
        elif thisPath in [
                "/client.html", "/monitor.html", "/instructions.html",
                "/video.html", "/questionnaire.html", "/quiz.html",
                "/serverInfo.html"
        ]:
            ext = ".py"
            filename = thisPath.replace(".html", ".py").replace("/", "")
            fileFolder = self.config['packageFolder'] + "/html/"
            fullPath = self.config['webServerRoot'] + fileFolder + filename
        elif thisPath in ["/console.html"]:
            try:
                thisPage = int(getValueFromQueryKey(parsedURL.query, "page"))
            except:
                "thisPage isn't integer"
                thisPage = ""
            if thisPage == "" or thisPage == "current":
                try:
                    thisPage = self.thisCounter.fileCount
                except:
                    thisPage = 1

            self.logURL = self.config['domain'] + self.config[
                'dataFolder'] + "/logs/%s.log" % (thisPage)
            self.currentLogTab = thisPage
            self.thisCounter.currentTab = thisPage
            ext = ".py"
            filename = thisPath.replace(".html", ".py").replace("/", "")
            fileFolder = self.config['packageFolder'] + "/html/"
            fullPath = self.config['webServerRoot'] + fileFolder + filename
        else:
            root, ext = os.path.splitext(thisPath)
            filename = os.path.basename(thisPath)
            if filename == "":
                filename = "index.py"
                ext = ".py"
            fileFolder = thisPath.replace(filename, "")
            fullPath = self.config['webServerRoot'] + fileFolder + filename
            if filename == "favicon.ico":
                fullPath = self.config['webServerRoot'] + self.config[
                    'packageFolder'] + "/html/triangle.png"
        if ext == ".zip":
            #will download the data file for ANY zip extension.
            dataFolder = self.config['webServerRoot'] + self.config[
                'dataFolder']
            outputName = self.config['webServerRoot'] + self.config[
                'currentExperiment'] + "/data/" + self.config[
                    'serverStartString']
            fullPath = outputName + ".zip"
            print("creating zip file ", fullPath, " for data folder ",
                  dataFolder)
            shutil.make_archive(outputName, 'zip', dataFolder)
            filename = self.config['serverStartString'] + ".zip"
            #this causes file to be downloaded automatically rather than being opened in the browser.
            request.setHeader("Content-Disposition", "attachment")
            thisFile = File(fullPath)
            # os.remove(fullPath)
            return File.render_GET(thisFile, request)
        elif os.path.isfile(fullPath):
            if filename == "console.py":
                print("running %s from %s" %
                      (filename, self.config['webServerRoot'] + fileFolder))
                thisPage = imp.load_source(
                    'thisPage',
                    self.config['webServerRoot'] + fileFolder + filename)
                output = thisPage.getPage(self.config,
                                          self.thisCounter.fileCount,
                                          self.currentLogTab)
                return output.encode('utf-8')
            elif ext == ".py":
                print("running %s from %s" %
                      (filename, self.config['webServerRoot'] + fileFolder))
                thisPage = imp.load_source(
                    'thisPage',
                    self.config['webServerRoot'] + fileFolder + filename)
                output = thisPage.getPage(self.config)
                return output.encode('utf-8')
            elif ext == ".m4a":
                request.setHeader("Content-Type", "audio/mp4")
                thisFile = File(self.config['webServerRoot'] + thisPath)
                return File.render_GET(thisFile, request)
            elif ext == ".pickle":
                #this causes file to be downloaded automatically rather than being opened in the browser.
                request.setHeader("Content-Disposition", "attachment")
                thisFile = File(self.config['webServerRoot'] + thisPath)
                return File.render_GET(thisFile, request)
            else:
                #print "getting file: "+self.config['webServerRoot']+fileFolder+filename
                thisFile = File(self.config['webServerRoot'] + fileFolder +
                                filename)
                return File.render_GET(thisFile, request)
        else:
            print(request)
            print("ErrorLine: File NOT found: %s" % (fullPath),
                  file=sys.stderr)
            #print >> sys.stderr, "ErrorLine: File NOT found: %s"%(fullPath)
            return "<html><h1>File Not Found - %s</h1></html>" % (fullPath)
Пример #51
0
if __name__ == '__main__':

    if len(sys.argv) > 1 and sys.argv[1] == 'debug':
        log.startLogging(sys.stdout)
        debug = True
    else:
        debug = False

    factory = WebSocketServerFactory("ws://127.0.0.1:8080",
                                     debug=debug,
                                     debugCodePaths=debug)

    factory.protocol = EchoServerProtocol
    factory.setProtocolOptions(
        allowHixie76=True)  # needed if Hixie76 is to be supported

    resource = WebSocketResource(factory)

    # we server static files under "/" ..
    root = File(".")

    # and our WebSocket server under "/ws"
    root.putChild("ws", resource)

    # both under one Twisted Web Site
    site = Site(root)
    site.protocol = HTTPChannelHixie76Aware  # needed if Hixie76 is to be supported
    reactor.listenTCP(8080, site)

    reactor.run()
Пример #52
0
from twisted.internet import reactor
from twisted.web.server import Site
from twisted.web.static import File

root = File('/')
root.putChild('var', File('/var'))
factory = Site(root)
reactor.listenTCP(8000, factory)
reactor.run()
Пример #53
0
    def onMessage(self, payload, isBinary):
        self.sendMessage(payload, isBinary)


if __name__ == '__main__':

    log.startLogging(sys.stdout)

    factory = WebSocketServerFactory("ws://127.0.0.1:9000")
    factory.protocol = EchoServerProtocol

    # Enable WebSocket extension "permessage-deflate".

    # Function to accept offers from the client ..
    def accept(offers):
        for offer in offers:
            if isinstance(offer, PerMessageDeflateOffer):
                return PerMessageDeflateOfferAccept(offer)

    factory.setProtocolOptions(perMessageCompressionAccept=accept)

    # run server
    listenWS(factory)

    webdir = File(".")
    web = Site(webdir)
    reactor.listenTCP(8080, web)

    reactor.run()
Пример #54
0
def static(request):
    """Return the static directory."""
    return File('static')
Пример #55
0
    if args.debug:
        from twisted.python import log
        log.startLogging(sys.stdout)

    ## import Twisted reactor
    ##
    from twisted.internet import reactor
    print("Using Twisted reactor {0}".format(reactor.__class__))

    ## create embedded web server for static files
    ##
    if args.web:
        from twisted.web.server import Site
        from twisted.web.static import File
        reactor.listenTCP(args.web, Site(File(".")))

    ## run WAMP application component
    ##
    from autobahn.twisted.wamp import ApplicationRunner
    router = args.router or 'ws://localhost:9000'

    runner = ApplicationRunner(
        router,
        u"realm1",
        standalone=not args.router,
        debug=False,  # low-level logging
        debug_wamp=args.debug,  # WAMP level logging
        debug_app=args.debug  # app-level logging
    )
Пример #56
0
        def __init__(self, *args, **kwargs):
            self._cache_timeout = kwargs.pop('cache_timeout', None)

            File.__init__(self, *args, **kwargs)
Пример #57
0
        p = Builder(self.server_ip, self.server_port, self.project,
                    self.version)
        p.factory = self
        return p


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='A.I.R Builder Daemon')
    parser.add_argument('--ip', default='127.0.0.1', help='server ip')
    parser.add_argument('--port',
                        dest='port',
                        default=8090,
                        type=int,
                        help='Server Port')
    parser.add_argument('project', help='Project')
    parser.add_argument('version', help='Version')
    parser.add_argument('img', help='Image file')
    parser.add_argument('log', help='Changelog file')

    options = parser.parse_args()
    print '[Client Started]'

    resource = File('%s' % os.getcwd())
    fileserver = Site(resource)
    reactor.listenTCP(8092, fileserver)

    reactor.connectTCP(
        options.ip, options.port,
        BuilderFactory(options.ip, options.port, options.project,
                       options.version, options.img, options.log))
    reactor.run()
Пример #58
0
def start_webserver(options,
                    protocol=wsl.ServerProtocol,
                    disableLogging=False):
    """
    Starts the web-server with the given protocol. Options must be an object
    with the following members:
        options.host : the interface for the web-server to listen on
        options.port : port number for the web-server to listen on
        options.timeout : timeout for reaping process on idle in seconds
        options.content : root for web-pages to serve.
    """
    from twisted.internet import reactor
    from twisted.web.server import Site
    from twisted.web.static import File
    import sys

    if not disableLogging:
        # redirect twisted logs to python standard logging.
        observer = log.PythonLoggingObserver()
        observer.start()
        # log.startLogging(sys.stdout)
        # Set logging level.
        if (options.debug): logging.basicConfig(level=logging.DEBUG)

    contextFactory = None

    use_SSL = False
    if options.sslKey and options.sslCert:
        use_SSL = True
        wsProtocol = "wss"
        from twisted.internet import ssl
        contextFactory = ssl.DefaultOpenSSLContextFactory(
            options.sslKey, options.sslCert)
    else:
        wsProtocol = "ws"

    # Create default or custom ServerProtocol
    wslinkServer = protocol()

    # create a wslink-over-WebSocket transport server factory
    transport_factory = wsl.TimeoutWebSocketServerFactory(\
           url        = "%s://%s:%d" % (wsProtocol, options.host, options.port),    \
           timeout    = options.timeout )
    transport_factory.protocol = wsl.WslinkWebSocketServerProtocol
    transport_factory.setServerProtocol(wslinkServer)

    root = Resource()

    # Do we serve static content or just websocket ?
    if len(options.content) > 0:
        # Static HTTP + WebSocket
        root = File(options.content)

    # Handle possibly complex ws endpoint
    if not options.nows:
        wsResource = WebSocketResource(transport_factory)
        handle_complex_resource_path(options.ws, root, wsResource)

    if options.uploadPath != None:
        from wslink.upload import UploadPage
        uploadResource = UploadPage(options.uploadPath)
        root.putChild("upload", uploadResource)

    if len(options.fsEndpoints) > 3:
        for fsResourceInfo in options.fsEndpoints.split('|'):
            infoSplit = fsResourceInfo.split('=')
            handle_complex_resource_path(infoSplit[0], root,
                                         File(infoSplit[1]))

    site = Site(root)

    if use_SSL:
        reactor.listenSSL(options.port, site, contextFactory)
    else:
        reactor.listenTCP(options.port, site)

    # flush ready line
    sys.stdout.flush()

    # Work around to force the output buffer to be flushed
    # This allow the process launcher to parse the output and
    # wait for "Start factory" to know that the WebServer
    # is running.
    if options.forceFlush:
        for i in range(200):
            log.msg("+" * 80, logLevel=logging.CRITICAL)

    # Initialize testing: checks if we're doing a test and sets it up
    # testing.initialize(options, reactor, stop_webserver)

    reactor.callWhenRunning(print_ready)

    # Start the reactor
    if options.nosignalhandlers:
        reactor.run(installSignalHandlers=0)
    else:
        reactor.run()
Пример #59
0
from twisted.internet import reactor
from twisted.web.server import Site
from twisted.web.static import File
root = File('..')
root.putChild("chapter-2", File(r"..\Chapter-2"))
root.putChild("chapter-3", File(r"..\Chapter-3"))
root.putChild("chapter-4", File(r"..\Chapter-4"))
factory = Site(root)
reactor.listenTCP(8000, factory)
reactor.run()