docFront/docker.py at master · raghav1674/docFront · GitHub

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
#!/usr/bin/python3

from datetime import datetime
import subprocess as sp
import json
import enum


# representing the state of container
class STATUS(enum.Enum):

    STOPPED = 'STOPPED'
    RUNNING = 'RUNNING'
    INACTIVE = 'INACTIVE'
    EXITED = 'EXITED'
    REMOVED = 'REMOVED'


# docker representation
class Docker:


    # List of all containers
    __containers = []

    # constructor

    def __init__(self,name,image,port_mapping=None):

        self.id = len(Docker.__containers) + 1
        self.created_at = datetime.now().isoformat()
        self.name = name
        self.image = image
        self.port_mapping = port_mapping
        self.status = STATUS.INACTIVE.value
        self.deleted_at = ''

    # serialize Docker object to json format
    def __serialize(self):

        container = {

            "name": self.name,
            "image": self.image,
            "status": self.status,
            "createdAt": self.created_at,


        }

        if self.deleted_at:

            container["deletedAt"] = self.deleted_at

        return json.dumps(container)


    # run the container in background
    def run(self):

        cmd = "sudo docker container run -dit --name {} {}".format(self.name,self.image)

        status,output = sp.getstatusoutput(cmd)

        if status == 0:

            self.status = STATUS.RUNNING.value

            Docker.__containers.append({ "_id": self.id, "data": self.__serialize()})

            return self.__serialize()
        else:

            self.status = STATUS.EXITED.value

            return self.__serialize()


    # stop and remove the container
    def delete(self):

        cmd_to_stop  = "sudo docker container stop {}".format(self.name)

        cmd_to_rm = "sudo docker container rm {}".format(self.name)

        stop_status,output = sp.getstatusoutput(cmd_to_stop)

        if stop_status == 0:

            self.status = STATUS.STOPPED.value

            removed_status,output = sp.getstatusoutput(cmd_to_rm)

            if removed_status == 0:

                self.status = STATUS.REMOVED.value

                self.deleted_at = datetime.now().isoformat()

                Docker.__containers = list(filter(lambda container: container["_id"] != self.id,Docker.__containers))

                return self.__serialize()


        else:
            self.status = STATUS.EXITED.value

            return self.__serialize()

    # get all the containers
    @classmethod
    def get_all(cls):

        return json.dumps(cls.__containers)

    # get a container
    @classmethod
    def get(cls,pk):

        return json.dumps({}) if pk > len(Docker.__containers) else cls.__containers[pk-1]["data"]