Beispiel #1
0
    def __init__(self, host, port=None, protocol=None,
                 security_policy=None, logger=None, reactor=None):
        logger = logger or log.get_default() or log.FluLogKeeper()
        log.LogProxy.__init__(self, logger)
        log.Logger.__init__(self, logger)
        self.reactor = reactor or treactor

        self._host = host
        self._port = port
        self._security_policy = security.ensure_policy(security_policy)

        if self._security_policy.use_ssl:
            self._http_scheme = http.Schemes.HTTPS
        else:
            self._http_scheme = http.Schemes.HTTP

        if self._port is None:
            if self._http_scheme is http.Schemes.HTTP:
                self._port = 80
            if self._http_scheme is http.Schemes.HTTPS:
                self._port = 443

        proto = self.default_http_protocol if protocol is None else protocol
        self._http_protocol = proto

        self._protocol = None
        self._pending = 0
        self.log_name = '%s:%d (%s)' % (
            self._host, self._port, self._http_scheme.name)
Beispiel #2
0
    def __init__(self, host, port=None, protocol=None,
                 security_policy=None, logger=None):
        logger = logger if logger is not None else log.FluLogKeeper()
        log.LogProxy.__init__(self, logger)
        log.Logger.__init__(self, logger)

        self._host = host
        self._port = port
        self._security_policy = security.ensure_policy(security_policy)

        if self._security_policy.use_ssl:
            self._http_scheme = http.Schemes.HTTPS
        else:
            self._http_scheme = http.Schemes.HTTP

        if self._port is None:
            if self._http_scheme is http.Schemes.HTTP:
                self._port = 80
            if self._http_scheme is http.Schemes.HTTPS:
                self._port = 443

        proto = self.default_http_protocol if protocol is None else protocol
        self._http_protocol = proto

        self._protocol = None
        self._pending = 0
Beispiel #3
0
    def __init__(self, root, port_range=None, hostname=None,
                 static_path=None, security_policy=None,
                 log_keeper=None, label=None, web_statistics=None,
                 interface=''):
        log.Logger.__init__(self, self)
        log.LogProxy.__init__(self, log_keeper or log.get_default())

        self._root = root
        self._label = label
        if not static_path:
            from feat.configure import configure
            static_path = configure.gatewaydir
        self._static_path = static_path

        tmp_range = port_range
        if isinstance(tmp_range, int):
            tmp_range = (tmp_range, tmp_range)
        try:
            min_port, max_port = tmp_range
            if not (isinstance(min_port, int)
                    and isinstance(max_port, int)
                    and min_port <= max_port):
                raise ValueError()
            self._ports = (min_port, max_port)
        except ValueError:
            raise ValueError("Invalid gateway port/range specified: %r"
                             % (port_range, ))

        self._host = hostname or socket.gethostbyaddr(socket.gethostname())[0]
        self._security = security.ensure_policy(security_policy)
        self._server = None
        self._interface = interface

        self._statistics = (web_statistics and
                            webserver.IWebStatistics(web_statistics))
Beispiel #4
0
    def __init__(self, log_keeper, port_range, dispatcher,
                 public_host=None, version=None, registry=None,
                 server_security_policy=None,
                 client_security_policy=None, max_delay=None):
        base.RangeServer.__init__(self, port_range,
                                  hostname=public_host,
                                  security_policy=server_security_policy,
                                  log_keeper=log_keeper)

        self._dispatcher = ITunnelDispatcher(dispatcher)

        ### protected attributes, used by Peer and/or Request ###
        ver = version if version is not None else feat.version
        self._version = int(ver)
        self._registry = registry

        self._client_security = security.ensure_policy(client_security_policy)

        self._uri = None

        self._retries = {} # {PEER_KEY: IDelayedCall}
        self._delays = {} # {PEER_KEY: DELAY}
        self._quarantined = set([]) # set([PEER_KEY])
        self._pendings = {} # {PEER_KEY: [(DEFERRED, PATH, DATA, EXPIRATION)]}
        self._peers = {} # {KEY: Peer}

        self._max_delay = max_delay or type(self).max_delay
Beispiel #5
0
    def __init__(self, root, port_range=None, security_policy=None):
        log.Logger.__init__(self, self)
        log.LogProxy.__init__(self, root)
        self._root = root

        self._ports = port_range
        self._security = security.ensure_policy(security_policy)
        self._server = None
Beispiel #6
0
    def __init__(self, agency, port_range=None, static_path=None, security_policy=None):
        log.Logger.__init__(self, self)
        log.LogProxy.__init__(self, agency)

        self._agency = agency
        if not static_path:
            static_path = os.path.join(os.path.dirname(__file__), "static")
        self._static_path = static_path

        self._host = socket.gethostbyaddr(socket.gethostname())[0]
        self._ports = port_range
        self._security = security.ensure_policy(security_policy)
        self._server = None
Beispiel #7
0
    def __init__(self, log_keeper, port_range, dispatcher,
                 public_host=None, version=None, registry=None,
                 server_security_policy=None,
                 client_security_policy=None):
        log.LogProxy.__init__(self, log_keeper)
        log.Logger.__init__(self, log_keeper)

        if public_host is None:
            public_host = socket.gethostbyaddr(socket.gethostname())[0]

        if isinstance(port_range, int):
            port_range = [port_range]

        self._port_range = port_range
        self._dispatcher = ITunnelDispatcher(dispatcher)
        self._public_host = public_host

        ### protected attributes, used by Peer and/or Request ###
        ver = version if version is not None else feat.version
        self._version = int(ver)
        self._registry = registry
        self._scheme = None

        self._server_security = security.ensure_policy(server_security_policy)
        self._client_security = security.ensure_policy(client_security_policy)

        self._server = httpserver.Factory(self, self)
        self._server.request_factory_class = RequestFactory

        self._port = None
        self._uri = None

        self._retries = {} # {PEER_KEY: IDelayedCall}
        self._delays = {} # {PEER_KEY: DELAY}
        self._quarantined = set([]) # set([PEER_KEY])
        self._pendings = {} # {PEER_KEY: [(DEFERRED, PATH, DATA, EXPIRATION)]}
        self._peers = {} # {KEY: Peer}
Beispiel #8
0
Datei: base.py Projekt: f3at/feat
    def __init__(self, port_or_range, hostname=None, security_policy=None, log_keeper=None):
        log_keeper = log_keeper or log.get_default() or log.FluLogKeeper()
        log.LogProxy.__init__(self, log_keeper)
        log.Logger.__init__(self, log_keeper)

        if hostname is None:
            hostname = socket.gethostbyaddr(socket.gethostname())[0]

        if isinstance(port_or_range, int):
            port_range = [port_or_range]
        else:
            port_range = port_or_range

        self._hostname = hostname
        self._port_range = port_range
        self._scheme = None

        self._security = security.ensure_policy(security_policy)

        self._factory = None
        self._port = None