Пример #1
0
    def run(self, medium=None, drive=None, timeout=120):
        """
        Mounts tape into drive

        Args:
            medium: Which medium to mount
            drive: Which drive to load to
        """

        medium = StorageMedium.objects.get(pk=medium)
        slot = medium.tape_slot.slot_id
        tape_drive = TapeDrive.objects.get(pk=drive)

        mount_tape(tape_drive.robot.device, slot, drive)

        wait_to_come_online(tape_drive.device, timeout)

        if medium.format not in [100, 101]:
            label_root = Path.objects.get(entity='label').value
            xmlpath = os.path.join(label_root,
                                   '%s_label.xml' % medium.medium_id)

            if tape_empty(tape_drive.device):
                create_tape_label(medium, xmlpath)
                rewind_tape(tape_drive.device)
                write_to_tape(tape_drive.device, xmlpath)
            else:
                tar = tarfile.open(tape_drive.device, 'r|')
                first_member = tar.getmembers()[0]

                if first_member.name.endswith('_label.xml'):
                    xmlstring = tar.extractfile(first_member).read()
                    tar.close()
                    if not verify_tape_label(medium, xmlstring):
                        raise ValueError(
                            'Tape contains labelfile with wrong tapeid')
                elif first_member.name == 'reuse':
                    tar.close()

                    create_tape_label(medium, xmlpath)
                    rewind_tape(tape_drive.device)
                    write_to_tape(tape_drive.device, xmlpath)
                else:
                    raise ValueError('Tape contains unknown information')

        TapeDrive.objects.filter(pk=drive).update(
            num_of_mounts=F('num_of_mounts') + 1, )
        StorageMedium.objects.filter(pk=medium.pk).update(
            num_of_mounts=F('num_of_mounts') + 1, tape_drive_id=drive)
Пример #2
0
def WriteToTape(self, medium, path, block_size=DEFAULT_TAPE_BLOCK_SIZE):
    """
    Writes content to a tape drive
    """

    try:
        drive = TapeDrive.objects.get(storage_medium__pk=medium)
    except TapeDrive.DoesNotExist:
        raise ValueError("Tape not mounted")

    write_to_tape(drive.device, path, block_size=block_size)

    drive.last_change = timezone.now()
    drive.save(update_fields=['last_change'])

    return None
Пример #3
0
    def write(self,
              src,
              ip,
              container,
              storage_medium,
              block_size=DEFAULT_TAPE_BLOCK_SIZE):
        block_size = storage_medium.block_size * 512

        last_written_obj = StorageObject.objects.filter(
            storage_medium=storage_medium).annotate(
                content_location_value_int=Cast(
                    'content_location_value', IntegerField())).order_by(
                        'content_location_value_int').only(
                            'content_location_value').last()

        if last_written_obj is None:
            tape_pos = 1
        else:
            tape_pos = last_written_obj.content_location_value_int + 1

        try:
            drive = TapeDrive.objects.get(storage_medium=storage_medium)
        except TapeDrive.DoesNotExist:
            raise ValueError("Tape not mounted")

        try:
            set_tape_file_number(drive.device, tape_pos)
            write_to_tape(drive.device, src, block_size=block_size)
        except OSError as e:
            if e.errno == errno.ENOSPC:
                storage_medium.mark_as_full()
                raise StorageMediumFull(
                    'No space left on storage medium "{}"'.format(
                        str(storage_medium.pk)))
            else:
                logger.exception('Error occurred when writing to tape')
                raise

        drive.last_change = timezone.now()
        drive.save(update_fields=['last_change'])

        return StorageObject.objects.create(content_location_value=tape_pos,
                                            content_location_type=TAPE,
                                            ip=ip,
                                            storage_medium=storage_medium,
                                            container=container)
Пример #4
0
def write_medium_label_to_drive(drive_id, medium, slot_id, tape_drive):
    xmlfile = tempfile.NamedTemporaryFile(delete=False)
    try:
        arcname = '%s_label.xml' % medium.medium_id

        if medium.format not in [100, 101]:
            if tape_empty(tape_drive.device):
                create_tape_label(medium, xmlfile.name)
                rewind_tape(tape_drive.device)
                write_to_tape(tape_drive.device, xmlfile.name, arcname=arcname)
            else:
                tar = tarfile.open(tape_drive.device, 'r|')
                first_member = tar.getmembers()[0]
                tar.close()
                rewind_tape(tape_drive.device)

                if first_member.name.endswith('_label.xml'):
                    tar = tarfile.open(tape_drive.device, 'r|')
                    xmlstring = tar.extractfile(first_member).read()
                    tar.close()
                    if not verify_tape_label(medium, xmlstring):
                        raise ValueError('Tape contains invalid label file')
                elif first_member.name == 'reuse':
                    create_tape_label(medium, xmlfile.name)
                    rewind_tape(tape_drive.device)
                    write_to_tape(tape_drive.device,
                                  xmlfile.name,
                                  arcname=arcname)
                else:
                    raise ValueError('Tape contains unknown information')

                rewind_tape(tape_drive.device)
    except BaseException:
        StorageMedium.objects.filter(pk=medium.pk).update(
            status=100,
            last_changed_local=timezone.now(),
        )
        TapeDrive.objects.filter(pk=drive_id).update(locked=False, status=100)
        TapeSlot.objects.filter(slot_id=slot_id).update(status=100)
        raise
    finally:
        xmlfile.close()
        TapeDrive.objects.filter(pk=drive_id).update(locked=False)
Пример #5
0
    def run(self, medium=None, path='.', block_size=DEFAULT_TAPE_BLOCK_SIZE):
        """
        Writes content to a tape drive
        """

        try:
            drive = TapeDrive.objects.get(storage_medium__pk=medium)
        except TapeDrive.DoesNotExist:
            raise ValueError("Tape not mounted")

        return write_to_tape(drive.device, path=path, block_size=block_size)
Пример #6
0
    def run(self, medium=None, drive=None, timeout=120):
        """
        Mounts tape into drive

        Args:
            medium: Which medium to mount
            drive: Which drive to load to
        """

        medium = StorageMedium.objects.get(pk=medium)
        slot = medium.tape_slot.slot_id
        tape_drive = TapeDrive.objects.get(pk=drive)

        if tape_drive.locked:
            raise TapeDriveLockedError()

        tape_drive.locked = True
        tape_drive.save(update_fields=['locked'])

        try:
            mount_tape(tape_drive.robot.device, slot, tape_drive.drive_id)
            wait_to_come_online(tape_drive.device, timeout)
        except:
            StorageMedium.objects.filter(pk=medium.pk).update(status=100)
            TapeDrive.objects.filter(pk=drive).update(locked=False, status=100)
            TapeSlot.objects.filter(slot_id=slot).update(status=100)
            raise

        TapeDrive.objects.filter(pk=drive).update(
            num_of_mounts=F('num_of_mounts') + 1,
            last_change=timezone.now(),
        )
        StorageMedium.objects.filter(pk=medium.pk).update(
            num_of_mounts=F('num_of_mounts') + 1, tape_drive_id=drive)

        xmlfile = tempfile.NamedTemporaryFile(delete=False)

        try:
            arcname = '%s_label.xml' % medium.medium_id

            if medium.format not in [100, 101]:
                if tape_empty(tape_drive.device):
                    create_tape_label(medium, xmlfile.name)
                    rewind_tape(tape_drive.device)
                    write_to_tape(tape_drive.device,
                                  xmlfile.name,
                                  arcname=arcname)
                else:
                    tar = tarfile.open(tape_drive.device, 'r|')
                    first_member = tar.getmembers()[0]
                    tar.close()
                    rewind_tape(tape_drive.device)

                    if first_member.name.endswith('_label.xml'):
                        tar = tarfile.open(tape_drive.device, 'r|')
                        xmlstring = tar.extractfile(first_member).read()
                        tar.close()
                        if not verify_tape_label(medium, xmlstring):
                            raise ValueError(
                                'Tape contains invalid label file')
                    elif first_member.name == 'reuse':
                        create_tape_label(medium, xmlfile.name)
                        rewind_tape(tape_drive.device)
                        write_to_tape(tape_drive.device,
                                      xmlfile.name,
                                      arcname=arcname)
                    else:
                        raise ValueError('Tape contains unknown information')

                    rewind_tape(tape_drive.device)
        except:
            StorageMedium.objects.filter(pk=medium.pk).update(status=100)
            TapeDrive.objects.filter(pk=drive).update(locked=False, status=100)
            TapeSlot.objects.filter(slot_id=slot).update(status=100)
            raise
        finally:
            xmlfile.close()
            TapeDrive.objects.filter(pk=drive).update(locked=False)