def __init__(self, client):
self.upload = Queue()
self.client = client
Resource.__init__(self)
t = UploadThread(self)
t.setDaemon(True)
t.start()
def __init__(self, rsrc, cookieKey=None):
Resource.__init__(self)
self.resource = rsrc
if cookieKey is None:
cookieKey = "woven_session_" + _sessionCookie()
self.cookieKey = cookieKey
self.sessions = {}
def __init__(self, hs, media_repo):
Resource.__init__(self)
self.auth = hs.get_auth()
self.clock = hs.get_clock()
self.version_string = hs.version_string
self.filepaths = media_repo.filepaths
self.max_spider_size = hs.config.max_spider_size
self.server_name = hs.hostname
self.store = hs.get_datastore()
self.client = SpiderHttpClient(hs)
self.media_repo = media_repo
self.url_preview_url_blacklist = hs.config.url_preview_url_blacklist
# simple memory cache mapping urls to OG metadata
self.cache = ExpiringCache(
cache_name="url_previews",
clock=self.clock,
# don't spider URLs more often than once an hour
expiry_ms=60 * 60 * 1000,
)
self.cache.start()
self.downloads = {}
def bravo_site(services):
# extract worlds and non-world services only once at startup
worlds = {}
other_services = {}
for name, service in services.iteritems():
factory = service.args[1]
if isinstance(factory, BravoFactory):
worlds[factory.name] = factory
else:
# XXX: do we really need those ?
other_services[name] = factory
# add site root
root = Resource()
root.putChild('', BravoResource(BravoRootElement(worlds, other_services)))
# add world sub pages and related plugins
for world, factory in worlds.iteritems():
# Discover parameterized plugins.
plugins = retrieve_plugins(IWorldResource,
parameters={"factory": factory})
# add sub page
child = BravoResource(BravoWorldElement(factory, plugins), False)
root.putChild(world, child)
# add plugins
for name, resource in plugins.iteritems():
# add plugin page
child.putChild(name, resource)
# create site
site = Site(root)
return site
class XMLRPCService(server.Site):
def __init__(self, port=None):
self._port = port or get_random_port()
self._addrs = []
self._root = Resource()
self._root.putChild('XMLRPC', XMLRPCResource(self._root))
server.Site.__init__(self, self._root)
def log(self, request):
log.info('%s http://localhost:%d%s' % (request.method,
self._port,
request.uri))
@property
def port(self):
return self._port
def serve(self):
log.info('Listening on port %d' % (self._port, ))
reactor.listenTCP(self._port, self)
def is_active(self):
return len(self._addrs)
def stop(self):
self._service.stopFactory()
def __init__(self, hs):
self.hs = hs
self.version_string = hs.version_string
self.response_body = encode_canonical_json(
self.response_json_object(hs.config)
)
Resource.__init__(self)
def __init__(self, host, port, path, path_rewrite=None, reactor=reactor,
tls=False, headers={}):
"""
@param host: the host of the web server to proxy.
@type host: C{str}
@param port: the port of the web server to proxy.
@type port: C{port}
@param path: the base path to fetch data from. Note that you shouldn't
put any trailing slashes in it, it will be added automatically in
request. For example, if you put B{/foo}, a request on B{/bar} will
be proxied to B{/foo/bar}. Any required encoding of special
characters (such as " " or "/") should have been done already.
@param path_rewrite: list of lists with two regexp strings
used for rewriting the path.
@param tls: use tls or not
@type path: C{str}
"""
Resource.__init__(self)
self.host = host
self.port = port
self.path = path
self.path_rewrite = path_rewrite
self.tls = tls
self.reactor = reactor
self.headers = headers
def setUp(self):
super(FlockerDeployTests, self).setUp()
ca_set, _ = get_credential_sets()
self.certificate_path = FilePath(self.mktemp())
self.certificate_path.makedirs()
ca_set.copy_to(self.certificate_path, user=True)
self.persistence_service = ConfigurationPersistenceService(
reactor, FilePath(self.mktemp()))
self.persistence_service.startService()
self.cluster_state_service = ClusterStateService(reactor)
self.cluster_state_service.startService()
self.cluster_state_service.apply_changes([
NodeState(uuid=uuid4(), hostname=ip)
for ip in COMPLEX_DEPLOYMENT_YAML[u"nodes"].keys()
])
self.addCleanup(self.cluster_state_service.stopService)
self.addCleanup(self.persistence_service.stopService)
app = ConfigurationAPIUserV1(self.persistence_service,
self.cluster_state_service).app
api_root = Resource()
api_root.putChild('v1', app.resource())
# Simplest possible TLS context that presents correct control
# service certificate; no need to validate flocker-deploy here.
self.port = reactor.listenSSL(
0,
Site(api_root),
DefaultOpenSSLContextFactory(
ca_set.path.child(b"control-127.0.0.1.key").path,
ca_set.path.child(b"control-127.0.0.1.crt").path),
interface="127.0.0.1")
self.addCleanup(self.port.stopListening)
self.port_number = self.port.getHost().port
def __init__(self, out=None, *a, **kw):
Resource.__init__(self, *a, **kw)
self._log = logging.getLogger(self.__class__.__name__)
self._log.debug('Initialized.')
if out is None:
out = sys.stdout
self.out = out
def create_api_service(persistence_service, cluster_state_service, endpoint,
context_factory, clock=reactor):
"""
Create a Twisted Service that serves the API on the given endpoint.
:param ConfigurationPersistenceService persistence_service: Service
for retrieving and setting desired configuration.
:param ClusterStateService cluster_state_service: Service that
knows about the current state of the cluster.
:param endpoint: Twisted endpoint to listen on.
:param context_factory: TLS context factory.
:param IReactorTime clock: The clock to use for time. By default
global reactor.
:return: Service that will listen on the endpoint using HTTP API server.
"""
api_root = Resource()
user = ConfigurationAPIUserV1(persistence_service, cluster_state_service,
clock)
api_root.putChild('v1', user.app.resource())
api_root._v1_user = user # For unit testing purposes, alas
return StreamServerEndpointService(
endpoint,
TLSMemoryBIOFactory(
context_factory,
False,
Site(api_root)
)
)
def _testRender(self, uri, expectedURI):
"""
Check that a request pointing at C{uri} produce a new proxy connection,
with the path of this request pointing at C{expectedURI}.
"""
root = Resource()
reactor = MemoryReactor()
resource = ReverseProxyResource("127.0.0.1", 1234, "/path", reactor)
root.putChild("index", resource)
site = Site(root)
transport = StringTransportWithDisconnection()
channel = site.buildProtocol(None)
channel.makeConnection(transport)
# Clear the timeout if the tests failed
self.addCleanup(channel.connectionLost, None)
channel.dataReceived("GET %s HTTP/1.1\r\nAccept: text/html\r\n\r\n" % (uri,))
# Check that one connection has been created, to the good host/port
self.assertEquals(len(reactor.tcpClients), 1)
self.assertEquals(reactor.tcpClients[0][0], "127.0.0.1")
self.assertEquals(reactor.tcpClients[0][1], 1234)
# Check the factory passed to the connect, and its given path
factory = reactor.tcpClients[0][2]
self.assertIsInstance(factory, ProxyClientFactory)
self.assertEquals(factory.rest, expectedURI)
self.assertEquals(factory.headers["host"], "127.0.0.1:1234")
def __init__(self):
Resource.__init__(self)
self.putChild("status", Status())
self.putChild("follow", Follow())
self.putChild("delay", Delay())
self.putChild("partial", Partial())
self.putChild("drop", Drop())
def test_posted(self):
root = Resource()
collector = Collector()
root.putChild(b"foo", collector)
from twisted.internet import reactor
while True:
try:
port = reactor.listenTCP(0, Site(root))
except:
pass
else:
self.addCleanup(port.stopListening)
port_number = port.getHost().port
break
fluentd_url = URL(
scheme="http",
host="127.0.0.1",
port=port_number,
path=["foo"],
)
agent = Agent(reactor)
destination = FluentdDestination(agent, fluentd_url)
destination({"hello": "world"})
def check():
self.assertEquals(collector.collected, [b'json={"hello": "world"}'])
return deferLater(reactor, 0.1, check)
def _put_plugin_resources(client_resource):
# Plugin resources and plugin info
load_list_css = []
load_list_js = []
mode_table = {}
plugin_resources = Resource()
client_resource.putChild('plugins', plugin_resources)
for resource_def in getPlugins(IClientResourceDef, shinysdr.plugins):
# Add the plugin's resource to static serving
plugin_resources.putChild(resource_def.key, resource_def.resource)
plugin_resource_url = '/client/plugins/' + urllib.quote(resource_def.key, safe='') + '/'
# Tell the client to load the plugins
# TODO constrain path values to be relative (not on a different origin, to not leak urls)
if resource_def.load_css_path is not None:
load_list_css.append(plugin_resource_url + resource_def.load_cs_path)
if resource_def.load_js_path is not None:
# TODO constrain value to be in the directory
load_list_js.append(plugin_resource_url + resource_def.load_js_path)
for mode_def in get_modes():
mode_table[mode_def.mode] = {
u'info_enum_row': mode_def.info.to_json(),
u'can_transmit': mode_def.mod_class is not None
}
# Client gets info about plugins through this resource
client_resource.putChild('plugin-index.json', static.Data(serialize({
u'css': load_list_css,
u'js': load_list_js,
u'modes': mode_table,
}).encode('utf-8'), 'application/json'))
def __init__(self, config, port=None):
super(IdentityServer, self).__init__(config)
self.plugin_mapping = config["plugin_mapping"]
self.setupMySQL(config)
self.setupIdentityQueue(config)
self.cassandra_cf_identity = config["cassandra_cf_identity"]
self.cassandra_cf_connections = config["cassandra_cf_connections"]
self.cassandra_cf_recommendations = config["cassandra_cf_recommendations"]
self.cassandra_cf_reverse_recommendations = config["cassandra_cf_reverse_recommendations"]
self.cassandra_client = CassandraClusterPool(
config["cassandra_servers"],
keyspace=config["cassandra_keyspace"],
pool_size=len(config["cassandra_servers"]) * 2)
self.cassandra_client.startService()
resource = Resource()
self.function_resource = Resource()
resource.putChild("function", self.function_resource)
if port is None:
port = config["identity_server_port"]
self.site_port = reactor.listenTCP(port, server.Site(resource))
self.expose(self.updateConnections)
self.expose(self.updateAllConnections)
self.expose(self.updateAllIdentities)
self.expose(self.getRecommendations)
self.expose(self.getReverseRecommendations)
self.expose(self.updateIdentity)
# setup manhole
manhole_namespace = {
'service': self,
'globals': globals(),
}
reactor.listenTCP(config["manhole_identity_port"], self.getManholeFactory(manhole_namespace, admin=config["manhole_password"]))
def __init__(self, ws, static_path=None):
self._ws = ws
if static_path is None:
static_path = os.path.join(os.path.dirname(__file__), 'static')
self._static_path = static_path
Resource.__init__(self)
def build_resource():
root = Resource()
for key, val in RESOURCE_MAPPING.iteritems():
root.putChild(key, val)
return root
def __init__(self, parent):
"""
Initialize
"""
parent.putChild(self.name, self)
Renderable.__init__(self, parent)
Resource.__init__(self)
def __init__(self):
Resource.__init__(self)
self.__path = ['']
self.__controllers = {}
self.__mapper = routes.Mapper()
def __init__(self, debug=False, signing_key=None, signing_id=None,
event_handler=GenericEventHandler):
Resource.__init__(self)
self.signing_key = signing_key
self.signing_id = signing_id
self.debug = debug # This class acts as a 'factory', debug is used by Protocol
self.event_handler = event_handler
def __init__(self, get_data_callback, clear_data_callback):
"""
"""
self.get_data_callback = get_data_callback
self.clear_data_callback = clear_data_callback
Resource.__init__(self)
def __init__(self, logDirResource, allowedChannels=None):
Resource.__init__(self)
self.logDirResource = logDirResource
allowed = allowedChannels
if allowed is not None:
allowed = set(unprefixedChannel(channel) for channel in allowedChannels)
self.allowed = allowed
def __init__(self, app, chunked=False, max_content_length=2 * 1024 * 1024,
block_length=8 * 1024):
Resource.__init__(self)
self.http_transport = TwistedHttpTransport(app, chunked,
max_content_length, block_length)
self._wsdl = None
def run_twisted(apps, port, static_dir='.'):
"""Twisted wrapper for the rpclib.server.wsgi.Application
Takes a list of tuples containing application, url pairs, and a port to
to listen to.
"""
if static_dir != None:
static_dir = os.path.abspath(static_dir)
logging.info("registering static folder %r on /" % static_dir)
root = twisted.web.static.File(static_dir)
else:
root = Resource()
for app, url in apps:
resource = WSGIResource(reactor, reactor, app)
logging.info("registering %r on /%s" % (app, url))
root.putChild(url, resource)
site = twisted.web.server.Site(root)
reactor.listenTCP(port, site)
logging.info("listening on: 0.0.0.0:%d" % port)
return reactor.run()
def __init__(self, cashier):
"""
:param cashier: The cashier we talk to
"""
Resource.__init__(self)
self.cashier = cashier
self.compropago = cashier.compropago
def run_server(fd=None, port=None, procs=None, verbose=False):
if args.verbose:
log.startLogging(stdout)
environ['SOLEDAD_LOG_TO_STDOUT'] = '1'
config = get_config()
path = config["blobs_path"]
if not port:
port = int(config["blobs_port"])
root = Resource()
root.putChild('blobs', BlobsResource("filesystem", path))
factory = Site(root)
if fd is None:
# Create a new listening port and several other
# processes to help out.
if procs is None:
procs = cpu_count()
log.msg('A total of %d processes will listen on port %d.' % (procs, port))
port = reactor.listenTCP(port, factory)
for i in range(procs - 1):
reactor.spawnProcess(
None, executable, [executable, __file__, str(port.fileno())],
childFDs={0: 0, 1: 1, 2: 2, port.fileno(): port.fileno()},
env=environ)
else:
# Another process created the port, just start listening on it.
log.msg('Adopting file descriptor %d...' % fd)
port = reactor.adoptStreamPort(fd, AF_INET, factory)
reactor.run()
def __init__(self, parent):
"""
"""
Resource.__init__(self)
self._parent = parent
self._debug = self._parent._debug
self.reactor = self._parent.reactor
def create_web_service(trompet, config):
"Creates the web service. Returns a tuple (service, site)."
site = Resource()
trompet.web = site
site.putChild("", Root())
service = internet.TCPServer(config["web"]["port"], server.Site(site))
service.setServiceParent(trompet)
def startService(self):
app = self._prov_service.app
dhcp_request_processing_service = self._dhcp_process_service.dhcp_request_processing_service
if self._config['general.rest_authentication']:
credentials = (self._config['general.rest_username'],
self._config['general.rest_password'])
server_resource = new_restricted_server_resource(app, dhcp_request_processing_service, credentials)
logger.info('Authentication is required for REST API')
else:
server_resource = new_server_resource(app, dhcp_request_processing_service)
logger.warning('No authentication is required for REST API')
root_resource = Resource()
root_resource.putChild('provd', server_resource)
rest_site = Site(root_resource)
port = self._config['general.rest_port']
interface = self._config['general.rest_ip']
if interface == '*':
interface = ''
logger.info('Binding HTTP REST API service to "%s:%s"', interface, port)
if self._config['general.rest_ssl']:
logger.info('SSL enabled for REST API')
context_factory = ssl.DefaultOpenSSLContextFactory(self._config['general.rest_ssl_keyfile'],
self._config['general.rest_ssl_certfile'])
self._tcp_server = internet.SSLServer(port, rest_site, context_factory, interface=interface)
else:
self._tcp_server = internet.TCPServer(port, rest_site, interface=interface)
self._tcp_server.startService()
Service.startService(self)
def __init__(self, source):
"""
@param source: The NotificationSource to fetch notifications from.
"""
Resource.__init__(self)
self.source = source
self._finished = {}
def __init__(self, database, subscription_id):
Resource.__init__(self)
self.database = database
self.subscription_id = subscription_id
def getChild(self, name, request):
if name == '':
return self
return Resource.getChild(self, name, request)
from twisted.web.server import Site, NOT_DONE_YET
from twisted.web.resource import Resource
from twisted.internet import reactor
from twisted.internet.task import deferLater
from twisted.python.log import err
# first consume 5, second consume 5 s
class DelayedResource(Resource):
def _delayRender(self, request):
request.write("<html><body>Sorry to keep you waiting.</body></html>")
request.finish()
def _responseFailed(self, failure, call):
call.cancel()
err(failure, "Async response demo interrupted response")
def render_GET(self, request):
call = reactor.callLater(5, self._delayRender, request)
request.notifyFinish().addErrback(self._responseFailed, call)
return NOT_DONE_YET
root = Resource()
root.putChild("x", DelayedResource())
factory = Site(root)
reactor.listenTCP(8888, factory)
reactor.run()
def __init__(self):
Resource.__init__(self)
self.putChild('incoming', IncomingResource())
def __init__(self, enable_blobs=False):
Resource.__init__(self)
server_info = ServerInfo(enable_blobs)
self.putChild('', server_info)
self.putChild('robots.txt', _Robots())
def __init__(self, database):
Resource.__init__(self)
self.database = database
def broken_client():
agent = MemoryAgent(Resource())
return Client(endpoint=b"", agent=agent, cooperator=Uncooperator())
def __init__(self, cell, wcommon):
Resource.__init__(self)
self._cell = cell
self.__note_dirty = wcommon.note_dirty
uniqueid = %s" % (clicktocall.uid, clicktocall.uid2)
print query
df = txdb.execute(query)
df.addCallback(self.onDb)
df.addErrback(self.errDb)
def onDb(self, result):
print("result db")
print result
self.result = result[len(result)-1]
print("Hello : ", self.result)
requests.write('''
<html><body>
<br>CDR : %s <br>
</body></html>
''' % self.result)
requests.finish()
def errDb(self, error):
print('error db')
print(error)
if __name__=="__main__":
root = Resource()
root.putChild("form1", FormPage())
root.putChild("form2", NewPage())
factory = Site(root)
reactor.listenTCP(8880, factory)
reactor.run()
storage=storage,
talos_vc=vc_server,
tls_port=args.tls_port)
if args.bootstrap is None:
server.bootstrap([("1.2.3.4", args.dhtport)])
else:
server.bootstrap([
(x, int(y))
for (x, y) in map(lambda tmp: tmp.split(':'), args.bootstrap)
])
else:
if args.secure:
server = TalosSecureDHTServer.loadState(args.dht_cache_file,
storage=storage,
talos_vc=vc_server)
else:
server = TalosDHTServer.loadState(args.dht_cache_file,
storage=storage,
talos_vc=vc_server)
server.listen(args.dhtport, interface=args.dhtserver)
server.saveStateRegularly(args.store_state_file)
root = Resource()
root.putChild("store_chunk", AddChunk(server))
root.putChild("chunk_address", GetChunkLoaction(server))
factory = Site(root)
reactor.listenTCP(args.restport, factory, interface=args.restserver)
reactor.run()
)
if not authenticated:
debug('Failed HTTP Basic auth, user: '******'__main__':
# Quick & dirty testing...
# create the intarweb
from twisted.web.server import Site
root = Resource()
sit = Site(HtPasswdWrapper(root, 'butt', 'head', 'test site'))
#sit = Site(root)
root.putChild(
'',
static.Data('If you can see this, you are authorized! Congrats!',
'text/plain'))
root.putChild('blah', static.Data('Bring me a child!!', 'text/plain'))
# and finally talk to the internat
from twisted.internet import reactor
reactor.listenTCP(18080, sit)
reactor.run()
"""
/*
def __init__(self, reactor, block):
Resource.__init__(self)
self.__reactor = reactor
self.__block = block
def __init__(self, process_service, pg_mgr):
Resource.__init__(self)
self._process_service = process_service
self._pg_mgr = pg_mgr
self.service_factory = _null_service_factory
def __init__(self, realm, errorPage):
Resource.__init__(self)
self.realm = realm
self.errorPage = errorPage
def __init__(self, callback):
self.callback = callback
Resource.__init__(self)
def __init__(self):
self.webAuthenticated = False
Resource.__init__(self)
from django.core.handlers.wsgi import WSGIHandler
# Environment setup for your Django project files:
#sys.path.append("cib_simulator")
sys.path.append("gameMT")
os.environ['DJANGO_SETTINGS_MODULE'] = 'gameMT.settings'
shared_messages = {}
resource = HttpShare(shared_messages)
factory = Site(resource)
ws_resource = WebSocketsResource(lookupProtocolForFactory(resource.wsFactory))
#Create a resource which will correspond to the root of the URL hierarchy: all URLs are children of this resource.
root = Resource()
root.putChild("",resource) #the http protocol is up at /
root.putChild("ws",ws_resource) #the websocket protocol is at /ws
# Twisted Application Framework setup:
application = service.Application("shareserver")
#This is the port for pass messages
internet.TCPServer(1035, Site(root)).setServiceParent(application)
#serving django over wsgi
# Create and start a thread pool,
wsgiThreadPool = ThreadPool()
wsgiThreadPool.start()
django_application = WSGIHandler()
def getChild(self, name, request):
if name == '':
self.isLeaf = True
return self
return Resource.getChild(self, name, request)
def __init__(self, year):
Resource.__init__(self)
self.year = year
def __init__(self):
Resource.__init__(self)
self.putChild("static", File("data/web_static"))
def __init__(self, coordinator):
Resource.__init__(self)
self.coordinator = coordinator
from twisted.web.server import Site
from twisted.web.resource import Resource
from twisted.internet import reactor, endpoints
import html
class FormPage(Resource):
def render_GET(self, request):
return (b"<!DOCTYPE html><html><head><meta charset='utf-8'>"
b"<title></title></head><body>"
b"<form method='POST'><input name='the-field'></form>")
def render_POST(self, request):
args = request.args[b"the-field"][0].decode("utf-8")
escapedArgs = html.escape(args)
return (b"<!DOCTYPE html><html><head><meta charset='utf-8'>"
b"<title></title></head><body>"
b"You submitted: " + escapedArgs.encode('utf-8'))
root = Resource()
root.putChild(b"form", FormPage())
factory = Site(root)
endpoint = endpoints.TCP4ServerEndpoint(reactor, 8880)
endpoint.listen(factory)
reactor.run()
def __init__(self, *args, **kwargs):
log.msg(
"DeprecationWarning: DOMController is deprecated; it has been renamed twisted.web.woven.controller.Controller.\n"
)
controller.Controller.__init__(self, *args, **kwargs)
Resource.__init__(self)
def __init__(self, hs):
Resource.__init__(self)
self._well_known_builder = WellKnownBuilder(hs)
def __init__(self, factory):
self.factory = factory
Resource.__init__(self)
def test_wrapResourceWeb(self):
from twisted.web.resource import IResource, Resource
root = Resource()
wrapped = wrapResource(root, [self.checker])
self.assertTrue(IResource.providedBy(wrapped))
def __init__(self, registry=None, path=None):
Resource.__init__(self)
self.path = path
self.registry = registry
def __init__(self, get_response_for):
"""
See :class:`StringStubbingResource`.
"""
Resource.__init__(self)
self._get_response_for = get_response_for
def __init__(self, nasmanager):
Resource.__init__(self)
self.nm = nasmanager
def __init__(self, path, callback):
Resource.__init__(self)
self._path = path.encode('charmap')
self._callback = callback