def __init__(self, request, client_address, server):
self.sc_session = server.sc_session
self.db_version_info = server.db_version_info
BaseHTTPRequestHandler.__init__(self, request, client_address, server)
def __init__(self, conn, addr, webserver, inits):
# /js/..., /imgs/..., and such just serve files
self.lits = ("js", "imgs", "css", "html")
# Code which, in turn, tries to dispatch ops
# (Each is (op, fn), e.g., ("GET", self.do_get1))
self.dispatchers = [ ("GET", self.base_get), ]
# Add on others (mixins)
for i in inits:
i(self)
# Default title
self.title = "web server"
# These get dicts if there are options
self.vals = self.rvals = None
# Hook for custom headers
self.extra_headers = []
# If authentication is active
self.user = None
# This both init's, and runs the web service
# (BTW, this sucks. Break out instance creation and
# service start--always.)
BaseHTTPRequestHandler.__init__(self, conn, addr, webserver)
def __init__(self, handler, methods, *args, **kwargs):
self._handler = handler
self._methods = methods
self._response_sent = False
self._headers_sent = False
self.logging = kwargs.get("logging", False)
BaseHTTPRequestHandler.__init__(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
self.routing = {
'/': self.index,
'/get_data': self.get_data,
'/manifest.appcache': self.manifest
}
BaseHTTPRequestHandler.__init__(self, *args, **kwargs)
def handle_one_request(self):
u"""1つのリクエストを処理する."""
try:
BaseHTTPRequestHandler.handle_one_request(self)
except socket.error, e:
logging.debug("%s stopped handling the request."\
" Reason: %s" % (self, str(e)))
def __init__(self, origin, *args):
#self.cache_c = collections.OrderedDict()
#self.cache_size = 10;
#self.cur_size = 0;
self.origin = origin
BaseHTTPRequestHandler.__init__(self,*args)
def __init__(self, *args, **kwargs):
self.numThreads = len(threading.enumerate())
print "Init was called and numThreads = %s" % self.numThreads
self.p = None
self.cnt = 0
self.start_time = 0
BaseHTTPRequestHandler.__init__(self, *args, **kwargs)
def __init__(self, resources, *args, **kwargs):
"""
:arg resources: A dict of resource paths pointing to content bytes
"""
self.resources = resources
BaseHTTPRequestHandler.__init__(self, *args, **kwargs)
def setup(self):
BaseHTTPRequestHandler.setup(self)
self.ip = self.client_address[0]
self.name = self.ip
if not hasattr(self, 'path'):
self.path = "not set"
self.size = 0
def __init__(self, *args, **kwargs):
from django.conf import settings
self.admin_media_prefix = settings.ADMIN_MEDIA_PREFIX
# We set self.path to avoid crashes in log_message() on unsupported
# requests (like "OPTIONS").
self.path = ''
BaseHTTPRequestHandler.__init__(self, *args, **kwargs)
def __init__(self, *args):
print "HSLRequestHandler::__init__()"
self._load_templates()
self.secret = self._get_secret()
print "\t self._get_secret(): %r" % self.secret
BaseHTTPRequestHandler.__init__(self, *args)
def __init__(self, request, client_address, server):
# Initialize the page handlers
# We always handle suite runner pages, and
# the runner dependencies (e.g. jasmine.js)
self._page_handlers = [SuitePageHandler(server.renderer, server.desc_dict),
RunnerPageHandler()]
# If we are configured for coverage, add another handler
# to serve instrumented versions of the source files.
if len(server.src_instr_dict) > 0:
# Create the handler to serve instrumented JS pages
instr_src_handler = InstrumentedSrcPageHandler(server.desc_dict,
server.src_instr_dict)
self._page_handlers.append(instr_src_handler)
# Create a handler to store coverage data POSTed back
# to the server from the client.
store_coverage_handler = StoreCoveragePageHandler(server.desc_dict,
server.coverage_data)
self._page_handlers.append(store_coverage_handler)
# We always serve dependencies. If running with coverage,
# the instrumented src handler will intercept source files.
# Serving the un-instrumented version is the fallback, and
# will still be used for library/spec dependencies.
self._page_handlers.append(DependencyPageHandler(server.desc_dict))
# Call the superclass implementation
# This will immediately call do_GET() if the request is a GET
BaseHTTPRequestHandler.__init__(self, request, client_address, server)
def __init__(self, *args, **kargs):
# We need a way to force self.close_connection:
self.eyefi_close_connection = False
self.session = None
# For some obscure reason, BaseHTTPRequestHandler.__init__ need to be
# called last:
BaseHTTPRequestHandler.__init__(self, *args, **kargs)
def handle_one_request(self):
try:
BaseHTTPRequestHandler.handle_one_request(self)
except socket.error, v:
# Ignoring connection reset by peer exceptions
if v[0] != errno.ECONNRESET:
raise
def __init__(self, *args, **kwargs):
# establish a database connection
engine = create_engine('sqlite:///restaurantmenu.db')
Base.metadata.bind = engine
DBSession = sessionmaker(bind = engine)
self.session = DBSession()
BaseHTTPRequestHandler.__init__(self, *args, **kwargs)
def __init__(self, request, client_address, server, app_object):
# type: (bytes, Tuple[str, int], HTTPServer, Chalice) -> None
self.app_object = app_object
self.event_converter = LambdaEventConverter(
RouteMatcher(list(app_object.routes)))
BaseHTTPRequestHandler.__init__(
self, request, client_address, server) # type: ignore
def __init__(self, *args):
addonSettings = xbmcaddon.Addon(id='plugin.video.xbmb3c')
level = addonSettings.getSetting('logLevel')
self.logLevel = 0
if(level != None):
self.logLevel = int(level)
BaseHTTPRequestHandler.__init__(self, *args)
def handle_one_request(self):
try:
BaseHTTPRequestHandler.handle_one_request(self)
except:
self.close_connection = 1
self.rfile = None
self.wfile = None
def log_request(self, *args, **kwargs):
"""
Override from BaseHTTPRequestHandler, so we can respect
the ProgressServer's disable_logging setting.
"""
if not self.server.disable_logging:
BaseHTTPRequestHandler.log_request(self, *args, **kwargs )
def __init__(self, request, client_address, server):
# FIXME workaround for exceptions in logs when the client broke connexion
try:
BaseHTTPRequestHandler.__init__(self, request, client_address, server)
except:
pass
self.server_version = 'QobuzXbmcHTTP/0.0.1'
def __init__(self, request, client_address, server):
print 'TaskCenterRequestHandler __init__'
self.db = Sqlite.DbPorxy.getInstance(server.db_path)
self.processMethodDict = {
'/getTaskList': self.getTaskList,
}
BaseHTTPRequestHandler.__init__(self, request, client_address, server)
def __init__(self, request, client_address, server):
self.request = request
self.client_address = client_address
self.server = server
self.proxy = server.my_object
self.data_string = None
BaseHTTPRequestHandler.__init__(self, request, client_address, server)
def __init__(self, *args, **kwargs):
self.oauth_server = oauth.OAuthServer(MockOAuthDataStore())
self.oauth_server.add_signature_method(
oauth.OAuthSignatureMethod_PLAINTEXT())
self.oauth_server.add_signature_method(
oauth.OAuthSignatureMethod_HMAC_SHA1())
BaseHTTPRequestHandler.__init__(self, *args, **kwargs)
def __init__(self, request, client_address, server):
self.protocol_version = "HTTP/1.0"
# setup xmlprc proxy
self.socketpath = '/home/ubuntu/mailsubmit/supervisor.sock'
self.proxy = xmlrpclib.ServerProxy('http://127.0.0.1',
transport=supervisor.xmlrpc.SupervisorTransport(None, None,
serverurl='unix://' + self.socketpath))
BaseHTTPRequestHandler.__init__(self, request, client_address, server);
def __init__(self, *args, **kwargs):
self.tls = threading.local()
self.tls.conns = {}
try:
BaseHTTPRequestHandler.__init__(self, *args, **kwargs)
except Exception,e:
print "[!] ERR:%s"%e
def handle_one_request(self):
try:
BaseHTTPRequestHandler.handle_one_request(self)
except socket.error, e:
if e.errno == errno.ECONNRESET:
pass # ignore the error
else:
raise
def log_message(self, format, *args):
if DEBUG:
try:
BaseHTTPRequestHandler.log_message(self, format, *args)
except IOError:
pass
else:
return
def __init__(self, request, client_address, server):
self.server = server
self.plugin = None
self.post_data = None
self.response_sent = False
BaseHTTPRequestHandler.__init__(self, request, client_address, server)
def __init__(self, *args, **kwargs):
from google.appengine._internal.django.conf import settings
self.admin_media_prefix = settings.ADMIN_MEDIA_PREFIX
# We set self.path to avoid crashes in log_message() on unsupported
# requests (like "OPTIONS").
self.path = ''
self.style = color_style()
BaseHTTPRequestHandler.__init__(self, *args, **kwargs)
def __init__(self, request, client_address, origin):
self.origin = origin
#if __name__ != '__main__':
# self.origin.log('postman initializing as plugin..', 2)
#else:
# self.origin.log('postman initializing as standalone application..', 2)
# ^ works
BaseHTTPRequestHandler.__init__(self, request, client_address, origin)
def finish(self):
try:
BaseHTTPRequestHandler.finish(self)
except socket.error:
pass
def log_message(self, format, *args):
sys.stderr.write("Mirroring: ")
BaseHTTPRequestHandler.log_message(self, format, *args)
def __init__(self, *args, **kwargs):
self._base_url = base_url
self.jar_name = ''.join(
random.choice(string.ascii_lowercase)
for _ in range(8)) + '.jar'
BaseHTTPRequestHandler.__init__(self, *args, **kwargs)
def __init__(self, request, client_address, server):
self.router = Router(self)
for key, value in ROUTES.items():
self.router.add(key, value)
BaseHTTPRequestHandler.__init__(self, request, client_address, server)
def __init__(self, *args, **kwargs):
self.tls = threading.local()
self.tls.conns = {}
BaseHTTPRequestHandler.__init__(self, *args, **kwargs)
def __init__(self, request, client_address, server):
# Data server reference for the master.
self.data_server = None
self.rebalance_id = None
BaseHTTPRequestHandler.__init__(self, request, client_address, server)
def __init__(self, *tupleArg, **jsonArg):
self.server_version = "CSERVER 1.0"
BaseHTTPRequestHandler.__init__(self, *tupleArg, **jsonArg)
def handle(self):
_service.Touch()
BaseHTTPRequestHandler.handle(self)
def log_message(self, format, *args):
sys.stderr.write("AirTunes: ")
BaseHTTPRequestHandler.log_message(self, format, *args)
def __init__(self, cache, origin, *args):
self.origin = origin
self.cache = cache
BaseHTTPRequestHandler.__init__(self, *args)
def __init__(self, dump_directory, *args): self._dump_directory = dump_directory BaseHTTPRequestHandler.__init__(self, *args)
def __init__(self, socket, address, server, version):
BaseHTTPRequestHandler.__init__(self, socket, address, server)
self.protocol_version = version
def setup(self):
self.timeout = 90000
BaseHTTPRequestHandler.setup(self)
self.request.settimeout(90000)
def finish(self):
try:
BaseHTTPRequestHandler.finish(self)
except socket.error as ex:
self.__handle_close_error(ex)
def __init__(self, request, client_address, server):
BaseHTTPRequestHandler.__init__(self, request, client_address, server)
def handle_one_request(self):
try:
BaseHTTPRequestHandler.handle_one_request(self)
except socket.error as ex:
self.__handle_close_error(ex)
def log_message(self, *args, **kwargs):
if not QUIET:
return BaseHTTPRequestHandler.log_message(self, *args, **kwargs)
def version_string(self):
return BaseHTTPRequestHandler.version_string(self).strip()
def __init__(self, nsa_queue, *args): self.nsa_queue = nsa_queue BaseHTTPRequestHandler.__init__(self, *args)
def __init__(self, *args, **kwargs):
BaseHTTPRequestHandler.__init__(self, *args, **kwargs)
def finish(self):
try:
BaseHTTPRequestHandler.finish(self)
except:
pass
def __init__(self, *args, **kwargs):
self._base_url = base_url
BaseHTTPRequestHandler.__init__(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
self.input_dict = input_dict
self.log_file = input_dict['log_file']
# self.playerVisibleBW = input_dict['playerVisibleBW']
# self.sessionHistory = input_dict['sessionHistory']
BaseHTTPRequestHandler.__init__(self, *args, **kwargs)
def __init__(self, request, client_address, server):
self.headers_set = []
self.headers_sent = []
self.header_buffer = ''
BaseHTTPRequestHandler.__init__(self, request, client_address, server)
def log_message(self, *args, **kwargs):
if self.verbose:
BaseHTTPRequestHandler.log_message(self, *args, **kwargs)
def __init__(self, request, client_address, server):
self.is_connect = False
BaseHTTPRequestHandler.__init__(self, request, client_address, server)
def __init__(self, registry, *args):
self.registry = registry
BaseHTTPRequestHandler.__init__(self, *args)
def handle(self):
try:
BaseHTTPRequestHandler.handle(self)
except socket.error:
pass
def __init__(self, model, *args):
self.model = model
BaseHTTPRequestHandler.__init__(self, *args)
def __init__(self, *args):
BaseHTTPRequestHandler.__init__(self, *args)
global games
global state
