← Back to branch summary

~citrix-openstack/nova/xenapi

« back to all changes in this revision

Viewing changes to nova/virt/disk.py

  • Committer: rlane at wikimedia
  • Date: 2011-03-03 23:04:11 UTC
  • mfrom: (408.9.363 nova)
  • mto: (408.9.366 nova)
  • mto: This revision was merged to the branch mainline in revision 449.
  • Revision ID: rlane@wikimedia.org-20110303230411-qx4qndimfyr1w1fx
Merge from trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/virt/disk.py
38
38
                     'minimum size in bytes of root partition')
39
39
flags.DEFINE_integer('block_size', 1024 * 1024 * 256,
40
40
                     'block_size to use for dd')
 
41
flags.DEFINE_integer('timeout_nbd', 10,
 
42
                     'time to wait for a NBD device coming up')
 
43
flags.DEFINE_integer('max_nbd_devices', 16,
 
44
                     'maximum number of possible nbd devices')
41
45
 
42
46
 
43
47
def extend(image, size):
45
49
    file_size = os.path.getsize(image)
46
50
    if file_size >= size:
47
51
        return
48
 
    utils.execute('truncate -s %s %s' % (size, image))
 
52
    utils.execute('truncate', '-s', size, image)
49
53
    # NOTE(vish): attempts to resize filesystem
50
 
    utils.execute('e2fsck -fp %s' % image, check_exit_code=False)
51
 
    utils.execute('resize2fs %s' % image, check_exit_code=False)
 
54
    utils.execute('e2fsck', '-fp', image, check_exit_code=False)
 
55
    utils.execute('resize2fs', image, check_exit_code=False)
52
56
 
53
57
 
54
58
def inject_data(image, key=None, net=None, partition=None, nbd=False):
64
68
    try:
65
69
        if not partition is None:
66
70
            # create partition
67
 
            out, err = utils.execute('sudo kpartx -a %s' % device)
 
71
            out, err = utils.execute('sudo', 'kpartx', '-a', device)
68
72
            if err:
69
73
                raise exception.Error(_('Failed to load partition: %s') % err)
70
74
            mapped_device = '/dev/mapper/%sp%s' % (device.split('/')[-1],
80
84
                                  mapped_device)
81
85
 
82
86
        # Configure ext2fs so that it doesn't auto-check every N boots
83
 
        out, err = utils.execute('sudo tune2fs -c 0 -i 0 %s' % mapped_device)
 
87
        out, err = utils.execute('sudo', 'tune2fs',
 
88
                                 '-c', 0, '-i', 0, mapped_device)
84
89
 
85
90
        tmpdir = tempfile.mkdtemp()
86
91
        try:
87
92
            # mount loopback to dir
88
93
            out, err = utils.execute(
89
 
                    'sudo mount %s %s' % (mapped_device, tmpdir))
 
94
                    'sudo', 'mount', mapped_device, tmpdir)
90
95
            if err:
91
96
                raise exception.Error(_('Failed to mount filesystem: %s')
92
97
                                      % err)
99
104
                    _inject_net_into_fs(net, tmpdir)
100
105
            finally:
101
106
                # unmount device
102
 
                utils.execute('sudo umount %s' % mapped_device)
 
107
                utils.execute('sudo', 'umount', mapped_device)
103
108
        finally:
104
109
            # remove temporary directory
105
 
            utils.execute('rmdir %s' % tmpdir)
 
110
            utils.execute('rmdir', tmpdir)
106
111
            if not partition is None:
107
112
                # remove partitions
108
 
                utils.execute('sudo kpartx -d %s' % device)
 
113
                utils.execute('sudo', 'kpartx', '-d', device)
109
114
    finally:
110
115
        _unlink_device(device, nbd)
111
116
 
114
119
    """Link image to device using loopback or nbd"""
115
120
    if nbd:
116
121
        device = _allocate_device()
117
 
        utils.execute('sudo qemu-nbd -c %s %s' % (device, image))
 
122
        utils.execute('sudo', 'qemu-nbd', '-c', device, image)
118
123
        # NOTE(vish): this forks into another process, so give it a chance
119
124
        #             to set up before continuuing
120
 
        for i in xrange(10):
 
125
        for i in xrange(FLAGS.timeout_nbd):
121
126
            if os.path.exists("/sys/block/%s/pid" % os.path.basename(device)):
122
127
                return device
123
128
            time.sleep(1)
124
129
        raise exception.Error(_('nbd device %s did not show up') % device)
125
130
    else:
126
 
        out, err = utils.execute('sudo losetup --find --show %s' % image)
 
131
        out, err = utils.execute('sudo', 'losetup', '--find', '--show', image)
127
132
        if err:
128
133
            raise exception.Error(_('Could not attach image to loopback: %s')
129
134
                                  % err)
133
138
def _unlink_device(device, nbd):
134
139
    """Unlink image from device using loopback or nbd"""
135
140
    if nbd:
136
 
        utils.execute('sudo qemu-nbd -d %s' % device)
 
141
        utils.execute('sudo', 'qemu-nbd', '-d', device)
137
142
        _free_device(device)
138
143
    else:
139
 
        utils.execute('sudo losetup --detach %s' % device)
140
 
 
141
 
 
142
 
_DEVICES = ['/dev/nbd%s' % i for i in xrange(16)]
 
144
        utils.execute('sudo', 'losetup', '--detach', device)
 
145
 
 
146
 
 
147
_DEVICES = ['/dev/nbd%s' % i for i in xrange(FLAGS.max_nbd_devices)]
143
148
 
144
149
 
145
150
def _allocate_device():
166
171
    fs is the path to the base of the filesystem into which to inject the key.
167
172
    """
168
173
    sshdir = os.path.join(fs, 'root', '.ssh')
169
 
    utils.execute('sudo mkdir -p %s' % sshdir)  # existing dir doesn't matter
170
 
    utils.execute('sudo chown root %s' % sshdir)
171
 
    utils.execute('sudo chmod 700 %s' % sshdir)
 
174
    utils.execute('sudo', 'mkdir', '-p', sshdir)  # existing dir doesn't matter
 
175
    utils.execute('sudo', 'chown', 'root', sshdir)
 
176
    utils.execute('sudo', 'chmod', '700', sshdir)
172
177
    keyfile = os.path.join(sshdir, 'authorized_keys')
173
 
    utils.execute('sudo tee -a %s' % keyfile, '\n' + key.strip() + '\n')
 
178
    utils.execute('sudo', 'tee', '-a', keyfile,
 
179
            process_input='\n' + key.strip() + '\n')
174
180
 
175
181
 
176
182
def _inject_net_into_fs(net, fs):
179
185
    net is the contents of /etc/network/interfaces.
180
186
    """
181
187
    netdir = os.path.join(os.path.join(fs, 'etc'), 'network')
182
 
    utils.execute('sudo mkdir -p %s' % netdir)  # existing dir doesn't matter
183
 
    utils.execute('sudo chown root:root %s' % netdir)
184
 
    utils.execute('sudo chmod 755 %s' % netdir)
 
188
    utils.execute('sudo', 'mkdir', '-p', netdir)  # existing dir doesn't matter
 
189
    utils.execute('sudo', 'chown', 'root:root', netdir)
 
190
    utils.execute('sudo', 'chmod', 755, netdir)
185
191
    netfile = os.path.join(netdir, 'interfaces')
186
 
    utils.execute('sudo tee %s' % netfile, net)
 
192
    utils.execute('sudo', 'tee', netfile, net)