예제 #1
0
    def _run_rsync(self):
        """ run rsync to pull out the rootfs /etc/ dir
            (later it is re-mounted inside the container so RHI can edit
            any needed files """

        # rsync -aqPS ${IMAGE}/etc .
        if os.path.exists(self.tmp_image_dir + "etc/"):
            cmd = ['rsync', '-aqPS', self.tmp_image_dir + "etc/", "/home/temp_etc/"]
            r = util.subp(cmd)
            if r.return_code != 0:
                raise EmulatorError('Rysnc unable to copy files: %s ' % cmd)

        # FIXME for some reason, some versions of RHEL containers don't have these dirs?
        # odd right?
        if not os.path.exists("/home/temp_etc/pki"):
            cmd = ['mkdir', '/home/temp_etc/etc/pki']
            r = util.subp(cmd)
            if r.return_code != 0:
                raise EmulatorError('Unable to make temporary directory: %s ' % cmd)

        if not os.path.exists("/home/temp_etc/pki/consumer"):
            cmd = ['mkdir', '/home/temp_etc/pki/consumer']
            r = util.subp(cmd)
            if r.return_code != 0:
                raise EmulatorError('Unable to make temporary directory: %s ' % cmd)
예제 #2
0
    def _remove_var_tmp_dir(self):
        """ remove the old location of where RHAI's output was stored """

        cmd = ['rm', '-rf', self.vartmp_dir]
        r = util.subp(cmd)
        if r.return_code != 0:
            print "vartmp dir did not remove"
예제 #3
0
    def _copy_launcher(self):
        """ copy the launching script into the rootfs/mnt dir """

        cmd = ['cp', '/home/insights-docker/launcher.sh', self.tmp_image_dir + '/mnt/']
        r = util.subp(cmd)
        if r.return_code != 0:
            raise EmulatorError('Unable to copy file: %s ' % cmd)
예제 #4
0
    def _copy_launcher(self):
        """ copy the launching script into the rootfs/mnt dir """

        cmd = ['cp', './launcher.sh', self.tmp_image_dir + '/mnt/']
        r = util.subp(cmd)
        if r.return_code != 0:
            print "could not copy launcher!"
예제 #5
0
    def _copy_resolve_conf(self):
        """ copy the host machines resolve.conf and put it into the rootfs' /etc/ dir """

        cmd = ['cp', '/etc/resolv.conf', self.tmp_image_dir + '/etc/']
        r = util.subp(cmd)
        if r.return_code != 0:
            raise EmulatorError('Unable to copy file: %s ' % cmd)
예제 #6
0
    def _mount_overlay(self, identifier):
        """
        OverlayFS mount backend.
        """

        cid = self._identifier_as_cid(identifier)
        cinfo = self.client.inspect_container(cid)

        ld, ud, wd = '', '', ''
        try:
            ld = cinfo['GraphDriver']['Data']['lowerDir']
            ud = cinfo['GraphDriver']['Data']['upperDir']
            wd = cinfo['GraphDriver']['Data']['workDir']
        except:
            ld, ud, wd = DockerMount._no_gd_api_overlay(cid)

        options = ['ro', 'lowerdir=' + ld, 'upperdir=' + ud, 'workdir=' + wd]
        optstring = ','.join(options)
        cmd = ['mount', '-t', 'overlay', '-o', optstring, 'overlay',
               self.mountpoint]
        status = util.subp(cmd)
        if status.return_code != 0:
            self._cleanup_container(cinfo)
            raise MountError('Failed to mount OverlayFS device.\n%s' %
                             status.stderr.decode(sys.getdefaultencoding()))

        return cid
예제 #7
0
 def inspect(self, obj_id):
     # returns dict representation of "docker inspect ID"
     cmd = ['docker', 'inspect', obj_id]
     r = util.subp(cmd)
     if r.return_code != 0:
         raise Exception('Unable to inspect object: %s' % obj_id)
     return json.loads(r.stdout)
예제 #8
0
def getDmsetupLs():
    cmd = ['dmsetup', 'ls']
    r = util.subp(cmd)
    if r.return_code != 0:
        print r.stderr
        return -1
    return r.stdout
예제 #9
0
파일: mount.py 프로젝트: yonglehou/atomic
 def _get_fs(thin_pathname):
     """
     Returns the file system type (xfs, ext4) of a given device
     """
     cmd = ['lsblk', '-o', 'FSTYPE', '-n', thin_pathname]
     fs_return = util.subp(cmd)
     return fs_return.stdout.strip()
예제 #10
0
파일: mount.py 프로젝트: yonglehou/atomic
 def unmount_path(path):
     """
     Unmounts the directory specified by path.
     """
     r = util.subp(['umount', path])
     if r.return_code != 0:
         raise ValueError(r.stderr)
예제 #11
0
    def remove_image(self, image_id):
        """ force removes image image_id """

        cmd = ['docker', 'rmi', '-f', image_id]
        out = util.subp(cmd)
        if out.return_code != 0:
            print "image was not deleted"
예제 #12
0
파일: mount.py 프로젝트: yonglehou/atomic
 def _remove_thin_device(name):
     """
     Destroys a thin device via subprocess call.
     """
     r = util.subp(['dmsetup', 'remove', name])
     if r.return_code != 0:
         raise MountError('Could not remove thin device:\n' + r.stderr)
예제 #13
0
    def chroot_and_run(self):
        """ give the chroot cmda and run the launcher script in the rootfs """

        cmd = ['chroot', self.tmp_image_dir, '/mnt/launcher.sh']
        r = util.subp(cmd)
        if r.return_code != 0:
            raise EmulatorError('Unable to start Insights Script: %s ' % cmd)
예제 #14
0
def remove_old_data():
    """ deleted old output """

    import util
    cmd = ['rm', '-rf', "/var/tmp/docker/"]
    r = util.subp(cmd)
    if r.return_code != 0:
        print "old data was not deleted"
예제 #15
0
 def unmount_path(path, force=False):
     """
     Unmounts the directory specified by path.
     """
     r = util.subp(['umount', path])
     if not force:
         if r.return_code != 0:
             raise ValueError(r.stderr)
예제 #16
0
def remove_old_data():
    """ deleted old output """

    import util
    cmd = ['rm', '-rf', "/var/tmp/docker/"]
    r = util.subp(cmd)
    if r.return_code != 0:
        print "old data was not deleted"
예제 #17
0
    def chroot_and_run(self):
        """ give the chroot cmda and run the launcher script in the rootfs """

        cmd = ['chroot', self.tmp_image_dir, '/mnt/launcher.sh']
        r = util.subp(cmd)
        if r.return_code != 0:
            print "could not chroot and run!"
            sys.exit()
예제 #18
0
    def commit(self, container):
        """ commits the container into a new image with the given tag """

        cmd = ['docker', 'commit', '-c', "ENV _RHAI_TEMP_CONTAINER=True", container]
        out = util.subp(cmd)
        if out.return_code != 0:
            print "image was not commited"
        return out.stdout.strip()
예제 #19
0
    def chroot_and_run(self):
        """ give the chroot cmda and run the launcher script in the rootfs """

        cmd = ['chroot', self.tmp_image_dir, '/mnt/launcher.sh']
        r = util.subp(cmd)
        if r.return_code != 0:
            print "could not chroot and run!"
            sys.exit()
예제 #20
0
    def inspect(self, obj_id):
        """ returns a dict of the inspection of a container or image """

        cmd = ['docker', 'inspect', obj_id]
        out = util.subp(cmd)
        trim_out = out.stdout.strip()
        ret = json.loads(trim_out[2:-2])
        return ret
예제 #21
0
def remove_old_data():
    """ deleted old output """

    temp_dir = "/var/tmp/docker/"
    cmd = ['rm', '-rf', temp_dir]
    r = util.subp(cmd)
    if r.return_code != 0:
        raise ValueError(str("Unable to remove directory %s."% temp_dir))
예제 #22
0
    def create_dirs(self):
        """ creates a dir of every entry in self.dir_list """

        for d in self.dir_list:
            if not os.path.exists(d):
                cmd = ['mkdir', d]
                r = util.subp(cmd)
                if r.return_code != 0:
                    raise EmulatorError('Not able to mount directory %s' % d )
예제 #23
0
    def create_dirs(self):
        """ creates a dir of every entry in self.dir_list """

        for d in self.dir_list:
            if not os.path.exists(d):
                cmd = ['mkdir', d]
                r = util.subp(cmd)
                if r.return_code != 0:
                    print "temp dirs did not mount"
예제 #24
0
    def create_dirs(self):
        """ creates a dir of every entry in self.dir_list """

        for d in self.dir_list:
            if not os.path.exists(d):
                cmd = ['mkdir', d]
                r = util.subp(cmd)
                if r.return_code != 0:
                    print "temp dirs did not mount"
예제 #25
0
    def _first_mounts(self):
        """ Mount the intial directories into the rootfs  """

        dir_list = ["/sys", "/proc", "/dev", "/tmp"]
        for d in dir_list:
            cmd = ['mount', '-o', "bind", d, self.tmp_image_dir + d]
            r = util.subp(cmd)
            if r.return_code != 0:
                raise EmulatorError('Unable to mount directory %s to %s' % 
                                    (d, self.tmp_image_dir + d) )

        # FIXME, can't remount shit into here cause 
        # VirtualBox's shared folders are read only, maybe not needed in prod version
        cmd = ['mount', '-o', "bind", "/home/temp_etc/", self.tmp_image_dir + "etc"]
        r = util.subp(cmd)
        if r.return_code != 0:
            raise EmulatorError('Unable to mount directory /home/temp_etc/ ' +
                                ' to %s ' % self.tmp_image_dir + 'etc')
예제 #26
0
파일: mount.py 프로젝트: yonglehou/atomic
    def get_dev_at_mountpoint(mntpoint):
        """
        Retrieves the device mounted at mntpoint, or raises
        MountError if none.
        """
        results = util.subp(['findmnt', '-o', 'SOURCE', mntpoint])
        if results.return_code != 0:
            raise MountError('No device mounted at ' + mntpoint)

        return results.stdout.replace('SOURCE\n', '').strip().split('\n')[-1]
예제 #27
0
    def _first_mounts(self):
        """ Mount the intial directories into the rootfs  """

        dir_list = ["/sys", "/proc", "/dev", "/tmp", "etc"]
        for d in dir_list:
            cmd = ['mount', '-o', "bind", d, self.tmp_image_dir + d]
            r = util.subp(cmd)
            if r.return_code != 0:
                print "mounting broke"
                print d
예제 #28
0
    def get_dev_at_mountpoint(mntpoint):
        """
        Retrieves the device mounted at mntpoint, or raises
        MountError if none.
        """
        results = util.subp(['findmnt', '-o', 'SOURCE', mntpoint])
        if results.return_code != 0:
            raise MountError('No device mounted at ' + mntpoint)

        return results.stdout.replace('SOURCE\n', '').strip().split('\n')[-1]
예제 #29
0
 def remove_thin_device(name,force=False):
     """
     Destroys a thin device via subprocess call.
     """
     cmd = ['dmsetup', 'remove', '--retry', name]
     r = util.subp(cmd)
     if not force:
         if r.return_code != 0:
             raise MountError('Could not remove thin device:\n%s' %
                              r.stderr.decode(sys.getdefaultencoding()).split("\n")[0])
예제 #30
0
    def _first_mounts(self):
        """ Mount the intial directories into the rootfs  """

        dir_list = ["/sys", "/proc", "/dev", "/tmp", "etc"]
        for d in dir_list:
            cmd = ['mount', '-o', "bind", d, self.tmp_image_dir + d]
            r = util.subp(cmd)
            if r.return_code != 0:
                print "mounting broke"
                print d
예제 #31
0
    def remove_dirs(self):
        """ remove directories in dir_list with a few exception dirs """

        for d in self.dir_list:
            if d not in [self.insights_output_dir, self.insights_dir,
                         self.vartmp_dir]:
                cmd = ['rm', '-rf', d]
                r = util.subp(cmd)
                if r.return_code != 0:
                    print "temp dirs did not remove"
예제 #32
0
    def remove_container(self, cont_id):
        """ *force* removes the given container id, fails if
            container ID isn't found """

        cmd = ['docker', 'rm', '-f', cont_id]
        out = util.subp(cmd)

        if out.return_code != 0:
            #FIXME RAISE EXCEPT HERE
            print "container ID not found, unable to remove object:"
            print cont_id
예제 #33
0
    def commit(self, container):
        """ commits the container into a new image with the given tag """

        cmd = [
            'docker', 'commit', '-c', "ENV _RHAI_TEMP_CONTAINER=True",
            container
        ]
        out = util.subp(cmd)
        if out.return_code != 0:
            print "image was not commited"
        return out.stdout.strip()
예제 #34
0
파일: mount.py 프로젝트: yonglehou/atomic
 def _is_device_active(device):
     """
     Checks dmsetup to see if a device is already active
     """
     cmd = ['dmsetup', 'info', device]
     dmsetup_info = util.subp(cmd)
     for dm_line in dmsetup_info.stdout.split("\n"):
         line = dm_line.split(':')
         if ('State' in line[0].strip()) and ('ACTIVE' in line[1].strip()):
             return True
     return False
예제 #35
0
    def create_container(self, iid):
        """ creates a container from image iid and returns the new
            container's id """

        cmd = ['docker', 'create', '--env=_RHAI_TEMP_CONTAINER',
               iid, '/bin/true']
        out = util.subp(cmd)

        if out.return_code != 0:
            print "container was not created"
        return out.stdout.strip()
예제 #36
0
 def remove_thin_device(name, force=False):
     """
     Destroys a thin device via subprocess call.
     """
     cmd = ['dmsetup', 'remove', '--retry', name]
     r = util.subp(cmd)
     if not force:
         if r.return_code != 0:
             raise MountError(
                 'Could not remove thin device:\n%s' %
                 r.stderr.decode(sys.getdefaultencoding()).split("\n")[0])
예제 #37
0
 def _activate_thin_device(name, dm_id, size, pool):
     """
     Provisions an LVM device-mapper thin device reflecting,
     DM device id 'dm_id' in the docker pool.
     """
     table = '0 %d thin /dev/mapper/%s %s' % (int(size) // 512, pool, dm_id)
     cmd = ['dmsetup', 'create', name, '--table', table]
     r = util.subp(cmd)
     if r.return_code != 0:
         raise MountError('Failed to create thin device: %s' %
                          r.stderr.decode(sys.getdefaultencoding()))
예제 #38
0
 def _activate_thin_device(name, dm_id, size, pool):
     """
     Provisions an LVM device-mapper thin device reflecting,
     DM device id 'dm_id' in the docker pool.
     """
     table = '0 {0} thin /dev/mapper/{1} {2}'.format(
         int(size) / 512, pool, dm_id)
     cmd = ['dmsetup', 'create', name, '--table', table]
     r = util.subp(cmd)
     if r.return_code != 0:
         raise MountError('Failed to create thin device: ' + r.stderr)
예제 #39
0
 def _is_device_active(device):
     """
     Checks dmsetup to see if a device is already active
     """
     cmd = ['dmsetup', 'info', device]
     dmsetup_info = util.subp(cmd)
     for dm_line in dmsetup_info.stdout.split("\n"):
         line = dm_line.split(':')
         if ('State' in line[0].strip()) and ('ACTIVE' in line[1].strip()):
             return True
     return False
예제 #40
0
파일: mount.py 프로젝트: yonglehou/atomic
 def _activate_thin_device(name, dm_id, size, pool):
     """
     Provisions an LVM device-mapper thin device reflecting,
     DM device id 'dm_id' in the docker pool.
     """
     table = '0 {0} thin /dev/mapper/{1} {2}'.format(int(size)/512,
                                                     pool, dm_id)
     cmd = ['dmsetup', 'create', name, '--table', table]
     r = util.subp(cmd)
     if r.return_code != 0:
         raise MountError('Failed to create thin device: ' + r.stderr)
예제 #41
0
    def remove_container(self, cont_id):
        """ *force* removes the given container id, fails if
            container ID isn't found """

        cmd = ['docker', 'rm', '-f', cont_id]
        out = util.subp(cmd)

        if out.return_code != 0:
            #FIXME RAISE EXCEPT HERE
            print "container ID not found, unable to remove object:"
            print cont_id
예제 #42
0
 def _activate_thin_device(name, dm_id, size, pool):
     """
     Provisions an LVM device-mapper thin device reflecting,
     DM device id 'dm_id' in the docker pool.
     """
     table = '0 %d thin /dev/mapper/%s %s' %  (int(size)//512, pool, dm_id)
     cmd = ['dmsetup', 'create', name, '--table', table]
     r = util.subp(cmd)
     if r.return_code != 0:
         raise MountError('Failed to create thin device: %s' %
                          r.stderr.decode(sys.getdefaultencoding()))
예제 #43
0
    def remove_dirs(self):
        """ remove directories in dir_list with a few exception dirs """

        for d in self.dir_list:
            if d not in [
                    self.insights_output_dir, self.insights_dir,
                    self.vartmp_dir
            ]:
                cmd = ['rm', '-rf', d]
                r = util.subp(cmd)
                if r.return_code != 0:
                    print "temp dirs did not remove"
예제 #44
0
    def images(self):
        """ returns a list of all image ids """

        cmd = ['docker', 'images', '-q', '--no-trunc']
        out = util.subp(cmd)
        trim_out = out.stdout.strip()
        return_list = []
        for line in trim_out.split('\n'):
            return_list.append(line)

        # return a set to remove dup ID's
        return list(set(return_list))
예제 #45
0
    def info(self):
        """ returns a dict of all of the docker info data"""

        cmd = ['docker', 'info']
        out = util.subp(cmd)
        trim_out = out.stdout.strip()
        return_dict = {}
        for line in trim_out.split('\n'):
            tmp_list = line.split(':', 1)
            return_dict[tmp_list[0].strip()] = tmp_list[1].strip()

        return return_dict
예제 #46
0
    def create_container(self, iid):
        """ creates a container from image iid and returns the new
            container's id """

        cmd = [
            'docker', 'create', '--env=_RHAI_TEMP_CONTAINER', iid, '/bin/true'
        ]
        out = util.subp(cmd)

        if out.return_code != 0:
            print "container was not created"
        return out.stdout.strip()
예제 #47
0
    def driver(self):
        # returns the storage driver docker is using
        cmd = ['docker', 'info']
        r = util.subp(cmd)
        if r.return_code != 0:
            raise Exception('Unable to get docker info')

        for line in r.stdout.strip().split('\n'):
            if line.startswith('Storage Driver'):
                pre, _, post = line.partition(':')
                return post.strip()
        raise Exception('Unable to get docker storage driver')
예제 #48
0
 def dm_pool(self):
     # ONLY FOR DEVICEMAPPER
     # returns the docker-pool docker is using
     cmd = ['docker', 'info']
     r = util.subp(cmd)
     if r.return_code != 0:
         raise Exception('Unable to get docker info')
     for line in r.stdout.strip().split('\n'):
         if line.strip().startswith('Pool Name'):
             pre, _, post = line.partition(':')
             return post.strip()
     raise Exception('Unable to get docker pool name')
예제 #49
0
    def gather_data(self, ims):
        """ Move the output dir into a designed output dir in /var/tmp/ """
        obj_type = ('images' if ims is True else 'containers')
        output_path = self.insights_output_dir + obj_type

        if not os.path.exists(output_path):
            cmd = ['mkdir', output_path]
            r = util.subp(cmd)
            if r.return_code != 0:
                print "could not make output directory"

        files = os.listdir(self.vartmp_dir)
        for f in files:
            cmd = ['mv', self.vartmp_dir + f, output_path]
            r = util.subp(cmd)
            if r.return_code != 0:
                print "could not move dir into output dir"
                print f
                print cmd

        self._remove_var_tmp_dir()
예제 #50
0
    def containers(self, running=True):
        """ returns a list of all container ids """

        if running:
            cmd = ['docker', 'ps', '-q', '--no-trunc']
        else:
            cmd = ['docker', 'ps', '-a', '-q', '--no-trunc']
        out = util.subp(cmd)
        trim_out = out.stdout.strip()
        return_list = []
        for line in trim_out.split('\n'):
            return_list.append(line)
        return return_list
예제 #51
0
 def unmount(self):
     """ unmount all mounted directories """
     dir_list = [
         "/var/tmp", "/var/log", "/mnt/opt/python", "/mnt",
         "/etc/pki/consumer", "/root/", "/sys", "/proc", "/dev", "/tmp",
         "etc"
     ]
     for d in dir_list:
         cmd = ['umount', self.tmp_image_dir + d]
         r = util.subp(cmd)
         if r.return_code != 0:
             print "unmounting broke"
             print d
예제 #52
0
 def mount_path(source, target, bind=False):
     """
     Subprocess call to mount dev at path.
     """
     cmd = ['mount']
     if bind:
         cmd.append('--bind')
     cmd.append(source)
     cmd.append(target)
     r = util.subp(cmd)
     if r.return_code != 0:
         raise MountError('Could not mount docker container:\n' +
                          ' '.join(cmd) + '\n%s' %
                          r.stderr.decode(sys.getdefaultencoding()))
예제 #53
0
    def _run_rsync(self):
        """ run rsync to pull out the rootfs /etc/ dir
            (later it is re-mounted inside the container so RHAI can edit
            any needed files """
        # rsync -aqPS ${IMAGE}/etc .
        if os.path.exists(self.tmp_image_dir + "etc/"):
            cmd = ['rsync', '-aqPS', self.tmp_image_dir + "etc/", "./etc/"]
            r = util.subp(cmd)
            if r.return_code != 0:
                print "rsync didn't copy correctly"

        # FIXME for some reason, some versions of RHEL containers don't have these dirs?
        # odd right?
        if not os.path.exists("./etc/pki"):
            cmd = ['mkdir', './etc/pki']
            r = util.subp(cmd)
            if r.return_code != 0:
                print "could not make temp pki directory"

        if not os.path.exists("./etc/pki/consumer"):
            cmd = ['mkdir', './etc/pki/consumer']
            r = util.subp(cmd)
            if r.return_code != 0:
                print "could not make temp consumer directory"
예제 #54
0
    def _prep_etc_dir(self):
        """ remove the RHAI dir from the mounted etc dir in the rootfs and
            Copy the RHAI source code into the rootfs etc dir """

        cmds = []
        cmds.append(
            ['rm', '-rf', self.tmp_image_dir + '/etc/redhat-access-insights'])
        cmds.append([
            'cp', '-r', self.insights_dir + '/etc/',
            self.tmp_image_dir + '/etc/redhat-access-insights'
        ])
        for c in cmds:
            r = util.subp(c)
            if r.return_code != 0:
                print "could not final prep the image's etc directory"
예제 #55
0
 def mount_path(source, target, optstring='', bind=False):
     """
     Subprocess call to mount dev at path.
     """
     cmd = ['mount']
     if bind:
         cmd.append('--bind')
     if optstring:
         cmd.append('-o')
         cmd.append(optstring)
     cmd.append(source)
     cmd.append(target)
     r = util.subp(cmd)
     if r.return_code != 0:
         raise MountError('Could not mount docker container:\n' +
                          ' '.join(cmd) + '\n' + r.stderr)
예제 #56
0
 def _get_overlay_mount_cid(self):
     """
     Returns the cid of the container mounted at mountpoint.
     """
     cmd = ['findmnt', '-o', 'OPTIONS', '-n', self.mountpoint]
     r = util.subp(cmd)
     if r.return_code != 0:
         raise MountError('No devices mounted at that location.')
     optstring = r.stdout.strip().split('\n')[-1]
     upperdir = [
         o.replace('upperdir=', '') for o in optstring.split(',')
         if o.startswith('upperdir=')
     ][0]
     cdir = upperdir.rsplit('/', 1)[0]
     if not cdir.startswith('/var/lib/docker/overlay/'):
         raise MountError('The device mounted at that location is not a '
                          'docker container.')
     return cdir.replace('/var/lib/docker/overlay/', '')
예제 #57
0
    def containers(self, allc=False, quiet=False):
        # returns a list of dicts, each dict is an containers's information
        # except when quiet is used - which returns a list of container ids
        # dict keys:
        # Status
        # Created
        # Image
        # Labels
        # NetworkSettings
        # HostConfig
        # ImageID
        # Command
        # Names
        # Id
        # Ports

        cmd = ['docker', 'ps', '-q']
        if allc:
            cmd.append("-a")
        r = util.subp(cmd)
        if r.return_code != 0:
            raise Exception('Unable to get docker containers')
        containers = r.stdout.strip().split('\n')
        if quiet:
            return containers
        else:
            conts = []
            for i in containers:
                inspec = self.inspect(i)
                inspec = inspec[0]
                dic = {}
                dic['Status'] = inspec['State']['Status']
                dic['Created'] = inspec['Created']
                dic['Image'] = inspec['Config']['Image']
                dic['Labels'] = inspec['Config']['Labels']
                dic['NetworkSettings'] = inspec['NetworkSettings']
                dic['HostConfig'] = inspec['HostConfig']
                dic['ImageID'] = inspec['Image']
                dic['Command'] = inspec['Config']['Cmd']
                dic['Names'] = inspec['Name']
                dic['Id'] = inspec['Id']
                dic['Ports'] = inspec['NetworkSettings']['Ports']
                conts.append(dic)
            return conts
예제 #58
0
 def images(self, allI=False, quiet=False):
     # returns a list of dicts, each dict is an image's information
     # except when quiet is used - which returns a list of image ids
     # dict keys:
     # Created
     # Labels
     # VirtualSize
     # ParentId
     # RepoTags
     # RepoDigests
     # Id
     # Size
     cmd = ['docker', 'images', '-q', '--no-trunc']
     if allI:
         cmd.append("-a")
     r = util.subp(cmd)
     if r.return_code != 0:
         raise Exception('Unable to get docker images')
     images = r.stdout.strip().split('\n')
     if quiet:
         return images
     else:
         ims = []
         for i in images:
             inspec = self.inspect(i)
             inspec = inspec[0]
             dic = {}
             dic['Created'] = inspec['Created']
             if inspec['Config']:
                 dic['Labels'] = inspec['Config']['Labels']
             else:
                 dic['Labels'] = {}
             dic['VirtualSize'] = inspec['VirtualSize']
             dic['ParentId'] = inspec['Parent']
             dic['RepoTags'] = inspec['RepoTags']
             dic['RepoDigests'] = inspec['RepoDigests']
             dic['Id'] = inspec['Id']
             dic['Size'] = inspec['Size']
             ims.append(dic)
         return ims
예제 #59
0
    def _mount_overlay(self, identifier, options):
        """
        OverlayFS mount backend.
        """
        if os.geteuid() != 0:
            raise MountError('Insufficient privileges to mount device.')

        if self.live:
            raise MountError('The OverlayFS backend does not support live '
                             'mounts.')
        elif 'rw' in options:
            raise MountError('The OverlayFS backend does not support '
                             'writeable mounts.')

        cid = self._identifier_as_cid(identifier)
        # cinfo = self.client.inspect_container(cid)
        cinfo = self.docker_client.inspect(cid)

        ld, ud, wd = '', '', ''
        try:
            #FIXME, GraphDriver isn't in inspect container output
            ld = cinfo['GraphDriver']['Data']['lowerDir']
            ud = cinfo['GraphDriver']['Data']['upperDir']
            wd = cinfo['GraphDriver']['Data']['workDir']
        except:
            ld, ud, wd = DockerMount._no_gd_api_overlay(cid)

        options += ['ro', 'lowerdir=' + ld, 'upperdir=' + ud, 'workdir=' + wd]
        optstring = ','.join(options)
        cmd = [
            'mount', '-t', 'overlay', '-o', optstring, 'overlay',
            self.mountpoint
        ]
        status = util.subp(cmd)

        if status.return_code != 0:
            self._cleanup_container(cinfo)
            raise MountError('Failed to mount OverlayFS device.\n' +
                             status.stderr.decode(sys.getdefaultencoding()))
예제 #60
0
 def _copy_resolve_conf(self):
     """ copy the host machines resolve.conf and put it into the rootfs' /etc/ dir """
     cmd = ['cp', '/etc/resolv.conf', self.tmp_image_dir + '/etc/']
     r = util.subp(cmd)
     if r.return_code != 0:
         print "could not make copy host's resolve.conf"