1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# subset of subprocess built-in module using posix_spawn rather than fork.

     5

     6

     7

     8

import os, sys

     9

import signal

    10

import shlex

    11

import posix_spawn

    12

    13

PIPE = "42"

    14

    15

fsencoding = sys.getfilesystemencoding()

    16

    17

class Popen(object):

    18

    def __init__(self, args, stdin=None, stdout=None, stderr=None):

    19

        self.returncode = None

    20

        self.stdout = None

    21

        self.stderr = None

    22

        self.stdin = None

    23

        file_actions = posix_spawn.FileActions()

    24

        if stdout is not None:

    25

            # child's stdout, child 2 parent pipe

    26

            c1pread, c1pwrite = os.pipe()

    27

            # attach child's stdout to writing en of c1p pipe

    28

            file_actions.add_dup2(c1pwrite, 1)

    29

            # close other end

    30

            file_actions.add_close(c1pread)

    31

        if stderr is not None:

    32

            # child's stderr, child 2 parent pipe

    33

            c2pread, c2pwrite = os.pipe()

    34

            # attach child's stderr to writing en of c2p pipe

    35

            file_actions.add_dup2(c2pwrite, 2)

    36

            # close other end

    37

            file_actions.add_close(c2pread)

    38

        if stdin is not None:

    39

            # child's stdin, parent to child pipe

    40

            p2cread, p2cwrite = os.pipe()

    41

            # attach child's stdin to reading en of p2c pipe

    42

            file_actions.add_dup2(p2cread, 0)

    43

            # close other end

    44

            file_actions.add_close(p2cwrite)

    45

        args = [s.encode(fsencoding) for s in args if type(s)==str]

    46

        self.pid = posix_spawn.posix_spawnp(args[0], args, file_actions=file_actions)

    47

        if stdout is not None:

    48

            self.stdout = os.fdopen(c1pread)

    49

            os.close(c1pwrite)

    50

        if stderr is not None:

    51

            self.stderr = os.fdopen(c2pread)

    52

            os.close(c2pwrite)

    53

        if stdin is not None:

    54

            self.stdin = os.fdopen(p2cwrite, 'w')

    55

            os.close(p2cread)

    56

    57

    def _wait(self):

    58

        if self.returncode is None:

    59

            self.returncode = os.waitpid(self.pid, 0)[1]

    60

    61

    def communicate(self):

    62

        if self.stdin is not None:

    63

            self.stdin.close()

    64

            self.stdin = None

    65

    66

        if self.stdout is not None:

    67

            stdoutdata = self.stdout.read()

    68

        else:

    69

            stdoutdata = ""

    70

    71

        if self.stderr is not None:

    72

            stderrdata = self.stderr.read()

    73

        else:

    74

            stderrdata = ""

    75

    76

        self._wait()

    77

    78

        if self.stdout is not None:

    79

            self.stdout.close()

    80

            self.stdout = None

    81

    82

        if self.stderr is not None:

    83

            self.stderr.close()

    84

            self.stderr = None

    85

    86

        return (stdoutdata, stderrdata)

    87

    88

    def wait(self):

    89

        if self.stdin is not None:

    90

            self.stdin.close()

    91

            self.stdin = None

    92

    93

        self._wait()

    94

    95

        if self.stdout is not None:

    96

            self.stdout.close()

    97

            self.stdout = None

    98

    99

        if self.stderr is not None:

   100

            self.stderr.close()

   101

            self.stderr = None

   102

   103

        return self.returncode

   104

   105

    def poll(self):

   106

        if self.returncode is None:

   107

            pid, ret = os.waitpid(self.pid, os.WNOHANG)

   108

            if (pid, ret) != (0, 0):

   109

                self.returncode = ret

   110

   111

                if self.stdin is not None:

   112

                    self.stdin.close()

   113

                    self.stdin = None

   114

   115

                if self.stdout is not None:

   116

                    self.stdout.close()

   117

                    self.stdout = None

   118

   119

                if self.stderr is not None:

   120

                    self.stderr.close()

   121

                    self.stderr = None

   122

   123

        return self.returncode

   124

   125

    def kill(self):

   126

        os.kill(self.pid, signal.SIGKILL)

   127

   128

        if self.stdin is not None:

   129

            self.stdin.close()

   130

            self.stdin = None

   131

   132

        if self.stdout is not None:

   133

            self.stdout.close()

   134

            self.stdout = None

   135

   136

        if self.stderr is not None:

   137

            self.stderr.close()

   138

            self.stderr = None

   139

   140

   141

def call(*args):

   142

    cmd = []

   143

    if isinstance(args[0], str):

   144

        if len(args) == 1:

   145

            # splitting of arguments that cares about 

   146

            # use of simple and double quotes

   147

            cmd = shlex.split(args[0])

   148

        else:

   149

            cmd = args

   150

    elif isinstance(args[0], list) and len(args) == 1:

   151

        cmd = args[0]

   152

    else:

   153

        raise Exception("Wrong arguments passed to subprocess.call")

   154

    pid = posix_spawn.posix_spawnp(cmd[0], cmd)

   155

    return os.waitpid(pid, 0)

   156

   157

   158

if __name__ == '__main__':

   159

    # unit test

   160

   161

    p = Popen(["tr", "abc", "def"], stdin=PIPE, stdout=PIPE)

   162

    p.stdin.write("blah")

   163

    p.stdin.close()

   164

    print(p.stdout.read())

   165

    p.wait()

   166

   167

    p = Popen(["tr", "abc", "def"], stdin=PIPE, stdout=PIPE)

   168

    p.stdin.write("blah")

   169

    print(p.communicate())

   170

   171

    call("echo blah0")

   172

    call(["echo", "blah1"])

   173

    call("echo", "blah2")