示例#1
0
def main(args):
    """Fetch workflows if requested and serve on localhost

    Args:
        args: arguments passed to this script
    """
    if args.fetch or args.tool_names:
        with open("hosts.json") as file:
            hosts = json.load(file)

        with ThreadPoolExecutor(max_workers=args.max_workers) as tpe:
            pbar = tqdm(hosts.items())
            result = tpe.map(
                partial(fetch_workflows, args.max_workflows, args.tool_names,
                        pbar),
                pbar,
            )
            result = list(result)

        print("Total number of workflows fetched: ", len(result))

        with open("workflows.json", "w") as file:
            json.dump(result, file, indent=4, sort_keys=True)

    test(CORSRequestHandler, HTTPServer, port=8082)
示例#2
0
def Start(handler,port=8000):
    server.test(
        HandlerClass=handler,
        ServerClass=server.ThreadingHTTPServer,
        port=port,
        bind=None,
    )
示例#3
0
 def _start(self):
     from http import server
     os.chdir(self.work_dir)
     server.test(HandlerClass=server.SimpleHTTPRequestHandler,
                 bind=self.bind,
                 port=self.port)
     RuntimeError('The HTTP server exits without calling stop()')
示例#4
0
 def test_server_test_localhost(self, _):
     mock_server = self.mock_server_class()
     server.test(ServerClass=mock_server, bind="localhost")
     self.assertIn(
         mock_server.address_family,
         (socket.AF_INET6, socket.AF_INET),
     )
示例#5
0
 def test_server_test_unspec(self, _):
     mock_server = self.mock_server_class()
     server.test(ServerClass=mock_server, bind=None)
     self.assertIn(
         mock_server.address_family,
         (socket.AF_INET6, socket.AF_INET),
     )
示例#6
0
 def test_server_test_unspec(self, _):
     mock_server = self.mock_server_class()
     server.test(ServerClass=mock_server, bind=None)
     self.assertIn(
         mock_server.address_family,
         (socket.AF_INET6, socket.AF_INET),
     )
示例#7
0
 def test_server_test_localhost(self, _):
     mock_server = self.mock_server_class()
     server.test(ServerClass=mock_server, bind="localhost")
     self.assertIn(
         mock_server.address_family,
         (socket.AF_INET6, socket.AF_INET),
     )
示例#8
0
def run_throttled_server(port: int = 8000, threshold: int = 10**6) -> None:
    _ = get_dataset("smallfile")
    _ = get_dataset("bigfile")
    _ = get_dataset_bz2("smallfile")
    _ = get_dataset_bz2("bigfile")
    os.chdir(DATA_DIR)
    ThrottledReqHandler.threshold = threshold
    http_srv.test(HandlerClass=ThrottledReqHandler, port=port)  # type: ignore
示例#9
0
 def _start(self):
     """ Equivalent to executing `python3 -m http.server` """
     os.chdir(self.work_dir)
     server.test(HandlerClass=server.SimpleHTTPRequestHandler,
                 bind=self.bind,
                 port=self.port)
     log.error('The HTTP server exits without calling stop()')
     print(log.to_str())
def serve(filename, port, bind):
    handler_class = partial(OPENAPIRequestHandler, openapi_file=filename)
    test(
        HandlerClass=handler_class,
        ServerClass=DualStackServer,
        port=port,
        bind=bind,
    )
示例#11
0
 def run(directory=None):
     SimpleHTTPRequestHandler.extensions_map = {
         k: f"{v};charset=UTF-8"
         for k, v in SimpleHTTPRequestHandler.extensions_map.items()
     }
     if directory is None:
         directory = sys.argv[1] if len(sys.argv) > 1 else "html"
     os.chdir(directory)
     test(SimpleHTTPRequestHandler)
示例#12
0
def main():
    args = parser.parse_args()
    if not args.bind:
        args.bind = None

    server.test(
        HandlerClass=MyHTTPRequestHandler,
        protocol="HTTP/1.1",
        port=args.port,
        bind=args.bind,
    )
示例#13
0
def main():
    import sys
    if 2 < sys.version_info[0]:
        import os
        import http.server as hs

        handler_class = hs.partial(hs.SimpleHTTPRequestHandler,
                                   directory=os.getcwd())
        hs.test(HandlerClass=handler_class, port=8000, bind='')
    else:
        from SimpleHTTPServer import test
        test()
def run_throttled_server(port=8000, threshold=10**6):
    _ = get_dataset('smallfile')
    _ = get_dataset('bigfile')
    _ = get_dataset_bz2('smallfile')
    _ = get_dataset_bz2('bigfile')
    os.chdir(DATA_DIR)
    ThrottledReqHandler.threshold = threshold
    if six.PY2:
        import sys
        sys.argv[1] = 8000
        http_srv.test(HandlerClass=ThrottledReqHandler)
    else:
        http_srv.test(HandlerClass=ThrottledReqHandler, port=port)
    def serve(self):
        outer = self

        class ClojureServer(HTTPServer):
            def __init__(self, *args, **kwargs):
                HTTPServer.__init__(self, *args, **kwargs)
                outer.server = self

        class CORSRequestHandler(SimpleHTTPRequestHandler):
            def end_headers(self):
                self.send_header("Access-Control-Allow-Origin", "*")
                SimpleHTTPRequestHandler.end_headers(self)

        test(CORSRequestHandler, ClojureServer)
示例#16
0
def docs(serve=False, port=5001):
    import subprocess
    from http.server import test, CGIHTTPRequestHandler
    from pathlib import Path

    docs_directory = Path(os.path.abspath(os.path.dirname(__file__))) / 'docs'

    with working_directory(str(docs_directory)):
        # Generate Documentation through Makefile
        subprocess.call('make html', shell=True)

    if serve:
        with working_directory(str(docs_directory / 'build/html')):
            test(HandlerClass=CGIHTTPRequestHandler, port=int(port), bind='')
示例#17
0
    def start_server(self, **kwargs):
        os.chdir(os.path.join(self.project_dir, "doc", "_build/html"))
        addr = self.default_addr
        port = self.default_port
        if kwargs["addrport"]:
            addrport = kwargs["addrport"].split(":")

            addr = addrport[0]

            if len(addrport) > 1:
                port = addrport[1]

            if not port.isnumeric():
                self.stdout.write("%s is not a valid port" % (port, ))
                sys.exit(0)

        test(HandlerClass=CGIHTTPRequestHandler, port=int(port), bind=addr)
示例#18
0
    def serve(self):
        outer = self

        try:
            from http.server import HTTPServer, SimpleHTTPRequestHandler, test
        except ImportError:  # Python 2
            from BaseHTTPServer import HTTPServer, test
            from SimpleHTTPServer import SimpleHTTPRequestHandler

        class ClojureServer(HTTPServer):
            def __init__(self, *args, **kwargs):
                HTTPServer.__init__(self, *args, **kwargs)
                outer.server = self

        class CORSRequestHandler(SimpleHTTPRequestHandler):
            def end_headers(self):
                self.send_header("Access-Control-Allow-Origin", "*")
                SimpleHTTPRequestHandler.end_headers(self)

        test(CORSRequestHandler, ClojureServer)
def main(preview_data=False):

    x, y = generate_images(nm_samples=70000, side_pixels=28)
    if preview_data:
        show_images(x[:100], [str(i) for i in y[:100]], shape=(28, 28))

    x_train = x[0:-10000]
    y_train = y[0:-10000]
    x_test = x[-10000:]
    y_test = y[-10000:]

    model = None
    with tf.device('/GPU:0'):

        config = tf.ConfigProto(log_device_placement=False)
        sess = tf.Session(config=config)
        K.set_session(sess)

        model = learn(x_train, y_train, x_test, y_test)

        PredictionServer.model = model
        server.test(HandlerClass=PredictionServer)
示例#20
0
def main():
    """ Parse args and call TarHTTPServer."""
    parser = argparse.ArgumentParser()
    parser.add_argument(
        '--bind',
        '-b',
        metavar='ADDRESS',
        help='Specify alternate bind address [default: all interfaces]')
    parser.add_argument(
        '--directory',
        '-d',
        default=os.getcwd(),
        help='Specify alternative directory [default:current directory]')
    parser.add_argument('port',
                        action='store',
                        default=8000,
                        type=int,
                        nargs='?',
                        help='Specify alternate port [default: 8000]')
    args = parser.parse_args()

    handler_class = partial(TarHTTPServer, directory=args.directory)
    test(HandlerClass=handler_class, port=args.port, bind=args.bind)
示例#21
0
    def test_server_test_ipv6(self, _):
        mock_server = mock.MagicMock()
        server.test(ServerClass=mock_server, bind="::")
        self.assertEqual(mock_server.address_family, socket.AF_INET6)

        mock_server.reset_mock()
        server.test(ServerClass=mock_server,
                    bind="2001:0db8:85a3:0000:0000:8a2e:0370:7334")
        self.assertEqual(mock_server.address_family, socket.AF_INET6)

        mock_server.reset_mock()
        server.test(ServerClass=mock_server,
                    bind="::1")
        self.assertEqual(mock_server.address_family, socket.AF_INET6)
示例#22
0
        self.send_response(206)
        self.send_header('Content-type', ctype)
        self.send_header('Accept-Ranges', 'bytes')

        if last is None or last >= file_len:
            last = file_len - 1
        response_length = last - first + 1

        self.send_header('Content-Range',
                         'bytes %s-%s/%s' % (first, last, file_len))
        self.send_header('Content-Length', str(response_length))
        self.send_header('Last-Modified', self.date_time_string(fs.st_mtime))
        self.end_headers()
        return f

    def copyfile(self, source, outputfile):
        if not self.range:
            return SimpleHTTPRequestHandler.copyfile(self, source, outputfile)

        # SimpleHTTPRequestHandler uses shutil.copyfileobj, which doesn't let
        # you stop the copying before the end of the file.
        start, stop = self.range  # set in send_head()
        copy_byte_range(source, outputfile, start, stop)


if __name__ == '__main__':
    os.chdir('public')
    build()
    test(HandlerClass=Handler)
示例#23
0
def run(HandlerClass=Handler, ServerClass=ThreadedHTTPServer):
    test(HandlerClass, ServerClass, port=PORT)
示例#24
0
def run_server():
    from http.server import test, SimpleHTTPRequestHandler
    os.chdir(OUTPUT)
    test(HandlerClass=SimpleHTTPRequestHandler)
示例#25
0
 def test_server_test_ipv4(self, _):
     for bind in self.ipv4_addrs:
         mock_server = self.mock_server_class()
         server.test(ServerClass=mock_server, bind=bind)
         self.assertEqual(mock_server.address_family, socket.AF_INET)
try:
    import http.server as server
except ImportError:
    # Handle Python 2.x
    import SimpleHTTPServer as server

class HTTPRequestHandler(server.SimpleHTTPRequestHandler):
    """Extend SimpleHTTPRequestHandler to handle PUT requests"""
    def do_PUT(self):
        """Save a file following a HTTP PUT request"""
        filename = os.path.basename(self.path)

        # Don't overwrite files
        if os.path.exists(filename):
            self.send_response(409, 'Conflict')
            self.end_headers()
            reply_body = '"%s" already exists\n' % filename
            self.wfile.write(reply_body.encode('utf-8'))
            return

        file_length = int(self.headers['Content-Length'])
        with open(filename, 'wb') as output_file:
            output_file.write(self.rfile.read(file_length))
        self.send_response(201, 'Created')
        self.end_headers()
        reply_body = 'Saved "%s"\n' % filename
        self.wfile.write(reply_body.encode('utf-8'))

if __name__ == '__main__':
    server.test(HandlerClass=HTTPRequestHandler)
示例#27
0
from http.server import HTTPServer, SimpleHTTPRequestHandler, test
import sys


class CORSRequestHandler(SimpleHTTPRequestHandler):
    def end_headers(self):
        self.send_header('Access-Control-Allow-Origin', '*')
        SimpleHTTPRequestHandler.end_headers(self)


if __name__ == '__main__':
    test(CORSRequestHandler,
         HTTPServer,
         port=int(sys.argv[1]) if len(sys.argv) > 1 else 8090)
    test.server_forever()
示例#28
0
#!/usr/bin/env python

from argparse import ArgumentParser
from http.server import SimpleHTTPRequestHandler, test

class DevelopmentRequestHandler(SimpleHTTPRequestHandler):

    # overrides
    def end_headers(self):
        self.add_no_cache_headers()
        super(SimpleHTTPRequestHandler, self).end_headers()
    
    def add_no_cache_headers(self):
        self.send_header('Cache-Control', 'no-cache, no-store, must-revalidate')
        self.send_header('Pragma', 'no-cache')
        self.send_header('Expires', '0')


if __name__ == '__main__':
    parser = ArgumentParser()
    parser.add_argument('port', action='store', default=8000, type=int, nargs='?', help='Specify alternate port [default: 8000]')
    args = parser.parse_args()
    
    test(HandlerClass=DevelopmentRequestHandler, port=args.port)
示例#29
0
def send_files(
    direction: DIRECTION,
    directory: Path,
    port: int = 11000,
    overwrite=False,
    password=None,
):
    '''
    Start a web server with a file upload form, provide the URL to access the
    files, and save the uploaded files to the specified directory.

    :param direction: "publish" or "receive"
    :param directory: Directory to publish or to receive into
    :param int port: Port to serve the web server on
    :param bool overwrite: Whether to allow an uploaded file to overwrite
        existing files (only applies for "receive" direction)
    :param password: Set the password manually. If you don't set a password,
        a random password will be generated. The password is included in the
        URL, so you don't need to tell anyone that a password is involved.
    '''

    # Inputs
    if direction == Direction.publish:
        if not directory.is_dir():
            msg = 'The source ("%s") must be a directory. Use "." for the current directory.'
            raise Error(msg % directory)
    else:
        if (not overwrite) and directory.exists():
            if any(directory.iterdir()):
                raise Error(
                    'The directory already exists. Choose a different destination or set -overwrite.'
                )
        makedirs(directory, exist_ok=True)

    # URL
    if not password:
        password = new_password()
    for url in urls(port, password):
        yield url

    # Serve
    if direction == Direction.publish:
        chdir(directory)

        class ProtectedHTTPRequestHandler(PrefixedHTTPRequestHandler):
            prefix = '/' + password

        test(HandlerClass=ProtectedHTTPRequestHandler, port=port)
    else:

        def endpoint(file: InputBinaryFile):
            '''
            Upload a file.

            :param file: File to send
            '''

            # Get and validate name.
            if file.filename in {'.', '..'}:
                raise Error('The name "%s" is reserved.' % file.filename)
            elif '/' in file.filename:
                raise Error('Name may not include slashes.')

            # Check if file exists.
            outpath = (directory / file.filename)
            if overwrite:
                pass
            elif outpath.exists():
                raise Error('A file named "%s" already exists.' %
                            file.filename)

            # Save
            with outpath.open('wb') as outfile:
                for chunk in file:
                    outfile.write(chunk)

            # Feedback
            return 'The file has been uploaded.'

        application = wsgi_form(Program({password: endpoint}, name=NAME))
        make_server('0.0.0.0', port, application).serve_forever()
from http.server import CGIHTTPRequestHandler,test

if __name__=='__main__':
    test(CGIHTTPRequestHandler)

'''
run this script and then in the browser open 127.0.0.1:8000/chapter10-cgibin.html
and the Submit button calls the script in the /cgi-bin folder
'''
示例#31
0
                        out.send(data)
                        count = 0
            else:
                logging.warning('Idle')
            if count == max_idling: break

    do_HEAD = do_GET
    do_POST = do_GET
    do_PUT  = do_GET
    do_DELETE=do_GET

class ThreadingHTTPServer(ThreadingMixIn, HTTPServer):
    pass

if __name__ == '__main__':
    from sys import argv
    if argv[1:] and argv[1] in ('-h', '--help'):
        print(argv[0], "[port [allowed_client_name ...]]")
    else:
        if argv[2:]:
            allowed = []
            for name in argv[2:]:
                client = socket.gethostbyname(name)
                allowed.append(client)
                logging.warning('Accepted: {} ({})'.format(client, name))
            ProxyHandler.allowed_clients = allowed
            del argv[2:]
        else:
            logging.warning('Waiting for clients')
        test(ProxyHandler, ThreadingHTTPServer)
示例#32
0
#!/usr/bin/python
'''
Use this in the same way as Python's SimpleHTTPServer:

  python -m RangeHTTPServer [port]

The only difference from SimpleHTTPServer is that RangeHTTPServer supports
'Range:' headers to load portions of files. This is helpful for doing local web
development with genomic data files, which tend to be to large to load into the
browser all at once.
'''

try:
    # Python3
    import http.server as SimpleHTTPServer

except ImportError:
    # Python 2
    import SimpleHTTPServer

from . import RangeRequestHandler


SimpleHTTPServer.test(HandlerClass=RangeRequestHandler)
示例#33
0
from http.server import CGIHTTPRequestHandler, test
test(CGIHTTPRequestHandler)
示例#34
0
  python -m RangeHTTPServer [port]

The only difference from SimpleHTTPServer is that RangeHTTPServer supports
'Range:' headers to load portions of files. This is helpful for doing local web
development with genomic data files, which tend to be to large to load into the
browser all at once.
'''

try:
    # Python3
    import http.server as SimpleHTTPServer

except ImportError:
    # Python 2
    import SimpleHTTPServer

from . import RangeRequestHandler

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('port',
                    action='store',
                    default=8000,
                    type=int,
                    nargs='?',
                    help='Specify alternate port [default: 8000]')

args = parser.parse_args()
SimpleHTTPServer.test(HandlerClass=RangeRequestHandler, port=args.port)
示例#35
0
          href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.1/css/bootstrap.min.css">
    </link>
    <link rel="stylesheet" type="text/css"
          href="https://bootswatch.com/4/darkly/bootstrap.css">
    </link>
</head>

<body>

<div class="jumbotron">
    <h1 class="display-4">Hello world!</h1>
    <p class="lead">This illustrates the power of Bootstrap.</p>
    <hr class="my-4">
    <p>It allows you to quickly create beautiful pages.</p>
    <a class="btn btn-primary btn-lg" href="#" role="button">Tell me more</a>
</div>

</html>
"""


class RequestHandler(server.BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.send_header("Content-type", "text/html")
        self.end_headers()
        self.wfile.write(TEMPLATE.encode("utf-8"))


server.test(RequestHandler, server.HTTPServer, port=8001, bind="0.0.0.0")
示例#36
0
import argparse
from http.server import HTTPServer, SimpleHTTPRequestHandler, test

class CORSRequestHandler(SimpleHTTPRequestHandler):
    def end_headers (self):
        self.send_header('Access-Control-Allow-Origin', '*')
        SimpleHTTPRequestHandler.end_headers(self)

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--bind', '-b', default='', metavar='ADDRESS',
                        help='Specify alternate bind address '
                             '[default: all interfaces]')
    parser.add_argument('port', action='store',
                        default=8000, type=int,
                        nargs='?',
                        help='Specify alternate port [default: 8000]')
    args = parser.parse_args()
    test(HandlerClass=CORSRequestHandler, port=args.port, bind=args.bind)
示例#37
0
#! /usr/bin/env python

# Usage: python __file__.py <port>

from http.server import SimpleHTTPRequestHandler, HTTPServer, test

class CORSRequestHandler(SimpleHTTPRequestHandler):
    def do_OPTIONS(self):
        self.send_response(200, 'OK')
        self.end_headers()

    def end_headers(self):
        self.send_header('Access-Control-Allow-Origin', '*')
        self.send_header('Access-Control-Allow-Headers', 'x-request-timestamp, x-signature, electricitymap-token')
        self.send_header('Cache-Control', 'no-cache, no-store, must-revalidate')
        self.send_header('Pragma', 'no-cache')
        self.send_header('Expires', '0')
        SimpleHTTPRequestHandler.end_headers(self)

if __name__ == '__main__':
    test(CORSRequestHandler, HTTPServer)
示例#38
0
def main(argv):
    global FILE, INDEX
    FILE = open(argv[1], 'rb')
    if not INDEX:
        INDEX = open(os.path.splitext(argv[0])[0] + '.html').read()
    server.test(HandlerClass=HTTPRequestHandler)
示例#39
0
#!/usr/bin/env python
from http import server


class MyHTTPRequestHandler(server.SimpleHTTPRequestHandler):
    def end_headers(self):
        self.send_my_headers()
        server.SimpleHTTPRequestHandler.end_headers(self)

    def send_my_headers(self):
        self.send_header("Cache-Control",
                         "no-cache, no-store, must-revalidate")
        self.send_header("Pragma", "no-cache")
        self.send_header("Expires", "0")


if __name__ == '__main__':
    server.test(HandlerClass=MyHTTPRequestHandler)
示例#40
0
        Return value is a string of the form type/subtype,
        usable for a MIME Content-type header.
        The default implementation looks the file's extension
        up in the table self.extensions_map, using application/octet-stream
        as a default; however it would be permissible (if
        slow) to look inside the data to make a better guess.
        """

        base, ext = posixpath.splitext(path)
        if ext in self.extensions_map:
            return self.extensions_map[ext]
        ext = ext.lower()
        if ext in self.extensions_map:
            return self.extensions_map[ext]
        else:
            return self.extensions_map['']

    if not mimetypes.inited:
        mimetypes.init()  # try to read system mime.types
    extensions_map = mimetypes.types_map.copy()
    extensions_map.update({
        '': 'application/octet-stream',  # Default
        '.py': 'text/plain',
        '.c': 'text/plain',
        '.h': 'text/plain',
    })


if __name__ == '__main__':
    test(FSS, HTTPServer)
示例#41
0
#!/usr/bin/env python3
from http.server import HTTPServer, SimpleHTTPRequestHandler, test
import sys


class CORSRequestHandler(SimpleHTTPRequestHandler):
    def end_headers(self):
        self.send_header('Access-Control-Allow-Origin', '*')
        SimpleHTTPRequestHandler.end_headers(self)


if __name__ == '__main__':
    test(CORSRequestHandler, HTTPServer, port=8000)
示例#42
0
except ImportError:
    from SimpleHTTPServer import SimpleHTTPRequestHandler
    import BaseHTTPServer


class CORSRequestHandler( SimpleHTTPRequestHandler ):
    '''
    This class provides an example server to allow local requests for the 
    data.json file in this output area demo.

    Making local file requests is not/should not be possible using the 
    XmlHttpRequest handler (for security reasons); in general javascript
    that fetches data from a different domain is frowned upon and is 
    legitimately a security concern, hence XSS (cross-site scripting) is not
    allowed.

    The solution to this is to allow CORS (cross-origin resource sharing), which allows
    the remote data to be fetched, but with much fewer security concerns than XSS.

    CORS is enabled server-side (there's nothing the client can do to request it,
    obviously) by adding the 'Access-Control-Allow-Origin' (ACAO) header to the 
    http response.
    '''
    def end_headers( self ):
        self.send_header( 'Access-Control-Allow-Origin', '*' )
        SimpleHTTPRequestHandler.end_headers(self)

        
if __name__ == '__main__':
    BaseHTTPServer.test( CORSRequestHandler, BaseHTTPServer.HTTPServer )
示例#43
0
def main():
    class PoolHTTPServer(PoolMixIn, HTTPServer):
        pool = ThreadPoolExecutor(max_workers=40)

    test(HandlerClass=SimpleHTTPRequestHandler, ServerClass=PoolHTTPServer)
def test():
    if sys.version_info[0] >= 3:
        http_server.test(RequestHandler, port=0)
    else:
        http_server.test(RequestHandler)
示例#45
0
 def test_server_test_ipv4(self, _):
     for bind in self.ipv4_addrs:
         mock_server = self.mock_server_class()
         server.test(ServerClass=mock_server, bind=bind)
         self.assertEqual(mock_server.address_family, socket.AF_INET)
示例#46
0
        self.send_header('Content-Length', str(response_length))
        self.send_header('Last-Modified', self.date_time_string(fs.st_mtime))
        self.end_headers()
        return f

    def copyfile(self, source, outputfile):
        if not self.range:
            return SimpleHTTPRequestHandler.copyfile(self, source, outputfile)

        # SimpleHTTPRequestHandler uses shutil.copyfileobj, which doesn't let
        # you stop the copying before the end of the file.
        start, stop = self.range  # set in send_head()
        copy_byte_range(source, outputfile, start, stop)


if __name__ == '__main__':
    if sys.version_info[0] == 2:
        http_server.test(HandlerClass=RangeRequestHandler)
        # Python2's SimpleHTTPServer.test doesn't support bind and port args
    else:
        parser = argparse.ArgumentParser()
        parser.add_argument('--bind', '-b', default='', metavar='ADDRESS',
                            help='Specify alternate bind address '
                                 '[default: all interfaces]')
        parser.add_argument('port', action='store',
                            default=8000, type=int,
                            nargs='?',
                            help='Specify alternate port [default: 8000]')
        args = parser.parse_args()
        http_server.test(HandlerClass=RangeRequestHandler, port=args.port, bind=args.bind)
示例#47
0
The port number is optional, defaulting to 8000. Once the server is up and
running with a swagger.json file in the same directory, then the url (assuming
port 8000) to be used in swagger-ui would be:

    http://localhost:8000/swagger.json

"""

from http.server import HTTPServer, SimpleHTTPRequestHandler, test
import sys


class CORSRequestHandler(SimpleHTTPRequestHandler):
    """
    Allows a simple HTTP server to have CORS enabled by default
    """
    def end_headers(self):
        self.send_header("Access-Control-Allow-Origin", "*")
        SimpleHTTPRequestHandler.end_headers(self)


if __name__ == "__main__":
    if len(sys.argv) > 1:
        # Allows the port to be passed in as an argument
        port = sys.argv[-1]
    else:
        port = 8000

    test(CORSRequestHandler, HTTPServer, port=port)
示例#48
0
#!/usr/bin/env python
# encoding: utf-8

from http import server

class TRACEServer(server.CGIHTTPRequestHandler):

    def do_TRACE(self):
        self.send_response(200, "Request follows")
        self.end_headers()

        self.wfile.write(self.raw_requestline)
        self.wfile.write(self.headers)

    def do_OPTIONS(self):
        self.send_response(200, "OK")
        self.send_header("Access-Control-Allow-Origin", "*")
        self.send_header("Access-Control-Allow-Credentials", "true")
        self.end_headers()

if __name__ == '__main__':
    server.test(HandlerClass=TRACEServer, port=8000)
示例#49
0
def test():
    if sys.version_info[0] >= 3:
        http_server.test(RequestHandler, port=0)
    else:
        http_server.test(RequestHandler)
示例#50
0
#/usr/bin/env python3

import argparse

from http import server as httpserver

class TestingRequestHandler(httpserver.SimpleHTTPRequestHandler):

    def translate_path(self, path):
        if not path.startswith("/static/"):
            if path == "/":
                path = "/global"
            path = "/out" + path + ".html"
        return super(TestingRequestHandler, self).translate_path(path)


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument('port', action='store',
                        default=8000, type=int,
                        nargs='?',
                        help='Specify alternate port [default: 8000]')
    args = parser.parse_args()
    handler_class = TestingRequestHandler
    httpserver.test(HandlerClass=handler_class, port=args.port)