python3-dockerpty 0.3.4-1build1 / usr / lib / python3 / dist-packages / dockerpty-0.3.4.egg-info / PKG-INFO

This file is indexed.

/usr/lib/python3/dist-packages/dockerpty-0.3.4.egg-info/PKG-INFO is in python3-dockerpty 0.3.4-1build1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
Metadata-Version: 1.1
Name: dockerpty
Version: 0.3.4
Summary: Python library to use the pseudo-tty of a docker container
Home-page: https://github.com/d11wtq/dockerpty
Author: Chris Corbyn
Author-email: chris@w3style.co.uk
License: Apache 2.0
Description: # Docker PTY
        
        Provides the functionality needed to operate the pseudo-tty (PTY) allocated to
        a docker container, using the Python client.
        
        [![Build Status](https://travis-ci.org/d11wtq/dockerpty.svg?branch=master)]
        (https://travis-ci.org/d11wtq/dockerpty)
        
        ## Installation
        
        Via pip:
        
        ```
        pip install dockerpty
        ```
        
        Dependencies:
        
          * docker-py>=0.3.2
        
        However, this library does not explicitly declare this dependency in PyPi for a
        number of reasons. It is assumed you have it installed.
        
        ## Usage
        
        The following example will run busybox in a docker container and place the user
        at the shell prompt via Python.
        
        This obviously only works when run in a terminal.
        
        ``` python
        import docker
        import dockerpty
        
        client = docker.Client()
        container = client.create_container(
            image='busybox:latest',
            stdin_open=True,
            tty=True,
            command='/bin/sh',
        )
        
        dockerpty.start(client, container)
        ```
        
        Keyword arguments passed to `start()` will be forwarded onto the client to
        start the container.
        
        When the dockerpty is started, control is yielded to the container's PTY until
        the container exits, or the container's PTY is closed.
        
        This is a safe operation and all resources are restored back to their original
        states.
        
        > **Note:** dockerpty does support attaching to non-tty containers to stream
        container output, though it is obviously not possible to 'control' the
        container if you do not allocate a pseudo-tty.
        
        If you press `C-p C-q`, the container's PTY will be closed, but the container
        will keep running. In other words, you will have detached from the container
        and can re-attach with another `dockerpty.start()` call.
        
        ## Tests
        
        If you want to hack on dockerpty and send a PR, you'll need to run the tests.
        In the features/ directory, are features/user stories for how dockerpty is
        supposed to work. To run them:
        
        ```
        -bash$ pip install -r requirements-dev.txt
        -bash$ behave features/
        ```
        
        You'll need to have docker installed and running locally. The tests use busybox
        container as a test fixture, so are not too heavy.
        
        Step definitions are defined in features/steps/.
        
        There are also unit tests for the parts of the code that are not inherently
        dependent on controlling a TTY. To run those:
        
        ```
        -bash$ pip install -r requirements-dev.txt
        -bash$ py.test tests/
        ```
        
        Travis CI runs this build inside a UML kernel that is new enough to run docker.
        Your PR will need to pass the build before I can merge it.
        
          - Travis CI build: https://travis-ci.org/d11wtq/dockerpty
        
        ## How it works
        
        In a terminal, the three file descriptors stdin, stdout and stderr are all
        connected to the controlling terminal (TTY). When you pass the `tty=True` flag
        to docker's `create_container()`, docker allocates a fake TTY inside the
        container (a PTY) to which the container's stdin, stdout and stderr are all
        connected.
        
        The docker API provides a way to access the three sockets connected to the PTY.
        If with access to the host system's TTY file descriptors and the container's
        PTY file descriptors, it is trivial to simply 'pipe' data written to these file
        descriptors between the host and the container. Doing this makes the user's
        terminal effectively become the pseudo-terminal from inside the container.
        
        In reality it's a bit more complicated than this, since care must be taken to
        put the host terminal into raw mode (where keys such as enter are not
        interpreted with any special meaning) and restore it on exit. Additionally, the
        container's stdout and stderr streams along with `sys.stdin` must be made
        non-blocking so that they can be used with `select()` without blocking the main
        process. These attributes are restored on exit.
        
        The size of a terminal cannot be controlled by sending data to stdin and can
        only be controlled by the terminal program itself. Since the pseudo-terminal is
        running inside a real terminal, it is import that the size of the PTY be kept
        the same as that of the presenting TTY. For this reason, docker provides an API
        call to resize the allocated PTY. A SIGWINCH handler is used to detect window
        size changes and resize the pseudo-terminal as needed.
        
        ## Contributors
        
          - Primary author: [Chris Corbyn](https://github.com/d11wtq)
          - Collaborator: [Daniel Nephin](https://github.com/dnephin)
          - Contributor: [Stephen Moore](https://github.com/delfick)
          - Contributor: [Ben Firshman](https://github.com/bfirsh)
        
        ## Copyright & Licensing
        
        Copyright © 2014 Chris Corbyn. See the LICENSE.txt file for details.
        
Keywords: docker,tty,pty,terminal
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Programming Language :: Python
Classifier: Environment :: Console
Classifier: Intended Audience :: Developers
Classifier: Topic :: Terminals
Classifier: Topic :: Terminals :: Terminal Emulators/X Terminals
Classifier: Topic :: Software Development :: Libraries
Classifier: Topic :: Software Development :: Libraries :: Python Modules

APT Browse - Built by Thomas Orozco.