Exemple #1
0
    def __register_thumb( self, path, obj, origin, name ):

        import mimetypes

        ext = os.path.splitext( path )[1]
        assert ext[0] == '.'
        ext = ext[1:]

        details = calculate_details( path )
        mime_type = mimetypes.guess_type( path, strict=False )[0]

        stream = model.Stream( obj.obj, name, model.SP_EXPENDABLE,
                               origin.stream, ext, mime_type )
        stream.set_details( *details )
        self.session.add( stream )

        log = model.StreamLog( stream, 'imgdb:' + name,
                               origin.stream, None )
        self.session.add( log )
        self.session.flush()

        self.imgdb.load_data( path, stream.stream_id,
                                    stream.priority,
                                    stream.extension )

        return model_stream_to_higu_stream( self, stream )
Exemple #2
0
    def __register_file( self, path, add_name ):

        name = os.path.split( path )[1].decode( sys.getfilesystemencoding() )
        details = calculate_details( path )

        try:
            results = self.lookup_files_by_details( *details )
            f = results.next()
        except StopIteration:
            obj = model.Object( TYPE_FILE )
            self.session.add( obj )
            fchk = model.FileChecksum( obj, *details )
            self.session.add( fchk )
            f = File( self, obj )
            self.session.flush()

        id = f.get_id()

        if( add_name ):
            f._add_name( name )

        if( not self.verify_file( f ) ):
            self.imgdb.load_data( path, id )

        return f
Exemple #3
0
    def __register_file( self, path, name_policy ):

        import mimetypes

        name = os.path.split( path )[1].decode( sys.getfilesystemencoding() )
        ext = os.path.splitext( name )[1]
        assert ext[0] == '.'
        ext = ext[1:]

        details = calculate_details( path )

        mime_type = mimetypes.guess_type( path, strict=False )[0]
        streams = self.lookup_streams_by_details( *details )
        new_stream = False

        if( len( streams ) == 0 ):
            obj = model.Object( TYPE_FILE )
            self.session.add( obj )
            stream = model.Stream( obj, '.', model.SP_NORMAL,
                                   None, ext, mime_type )
            stream.set_details( *details )
            self.session.add( stream )
            obj.root_stream = stream

            f = model_obj_to_higu_obj( self, obj )
            stream = model_stream_to_higu_stream( self, stream )
            new_stream = True

            self.session.flush()
            f._on_created( stream )
        else:
            stream = streams[0]
            if( stream.stream.mime_type is None ):
                stream.stream.mime_type = mime_type

            f = stream._get_file()

        if( name_policy == NAME_POLICY_DONT_REGISTER ):
            log = model.StreamLog( stream.stream, 'hdbfs:register',
                                   None, None )
        else:
            log = model.StreamLog( stream.stream, 'hdbfs:register',
                                   None, name )

        self.session.add( log )

        if( name_policy == NAME_POLICY_SET_ALWAYS
         or (name_policy == NAME_POLICY_SET_IF_UNDEF
         and f.obj.name is None) ):

            f.obj.name = name

        if( not stream._verify() ):
            self.imgdb.load_data( path, stream.stream.stream_id,
                                        stream.stream.priority,
                                        stream.stream.extension )

        return f, stream, new_stream
Exemple #4
0
    def __register_file(self, path, name_policy):

        import mimetypes

        name = os.path.split(path)[1].decode(sys.getfilesystemencoding())
        ext = os.path.splitext(name)[1]
        assert ext[0] == '.'
        ext = ext[1:]

        details = calculate_details(path)

        mime_type = mimetypes.guess_type(path, strict=False)[0]
        streams = self.lookup_streams_by_details(*details)
        new_stream = False

        if (len(streams) == 0):
            obj = model.Object(TYPE_FILE)
            self.session.add(obj)
            stream = model.Stream(obj, '.', model.SP_NORMAL, None, ext,
                                  mime_type)
            stream.set_details(*details)
            self.session.add(stream)
            obj.root_stream = stream

            f = model_obj_to_higu_obj(self, obj)
            stream = model_stream_to_higu_stream(self, stream)
            new_stream = True

            self.session.flush()
            f._on_created(stream)
        else:
            stream = streams[0]
            if (stream.stream.mime_type is None):
                stream.stream.mime_type = mime_type

            f = stream._get_file()

        if (name_policy == NAME_POLICY_DONT_REGISTER):
            log = model.StreamLog(stream.stream, 'hdbfs:register', None, None)
        else:
            log = model.StreamLog(stream.stream, 'hdbfs:register', None, name)

        self.session.add(log)

        if (name_policy == NAME_POLICY_SET_ALWAYS or
            (name_policy == NAME_POLICY_SET_IF_UNDEF and f.obj.name is None)):

            f.obj.name = name

        if (not stream._verify()):
            self.imgdb.load_data(path, stream.stream.stream_id,
                                 stream.stream.priority,
                                 stream.stream.extension)

        return f, stream, new_stream
Exemple #5
0
    def __recover_file( self, path ):

        name = os.path.split( path )[1]

        details = calculate_details( path )
        results = self.lookup_files_by_details( *details )

        try:
            f = results.next()
        except StopIteration:
            return False

        if( not self.verify_file( f ) ):
            self.imgdb.load_data( path, f.get_id() )
        return True
Exemple #6
0
    def _verify( self ):

        fd = self._read()

        if( fd is None ):
            return False

        details = calculate_details( fd )

        if( details[0] != self.stream.stream_length ):
            return False
        if( details[1] != self.stream.hash_crc32 ):
            return False
        if( details[2] != self.stream.hash_md5 ):
            return False
        if( details[3] != self.stream.hash_sha1 ):
            return False

        return True
Exemple #7
0
    def verify_file( self, obj ):

        assert isinstance( obj, File )
        fd = obj.read()

        if( fd is None ):
            return False

        details = calculate_details( fd )

        if( details[0] != obj.obj.fchk.len ):
            return False
        if( details[1] != obj.obj.fchk.crc32 ):
            return False
        if( details[2] != obj.obj.fchk.md5 ):
            return False
        if( details[3] != obj.obj.fchk.sha1 ):
            return False

        return True
Exemple #8
0
    def __recover_file( self, path ):

        import mimetypes

        name = os.path.split( path )[1]

        details = calculate_details( path )
        streams = self.lookup_streams_by_details( *details )

        if( len( streams ) == 0 ):
            return False

        if( not streams[0]._verify() ):
            self.imgdb.load_data( path, streams[0].stream.stream_id,
                                        streams[0].stream.priority,
                                        streams[0].stream.extension )

            ext = os.path.splitext( path )[1]
            assert ext[0] == '.'
            streams[0].stream.extension = ext[1:]
            streams[0].stream.mime_type = mimetypes.guess_type( path, strict=False )[0]
        return True
Exemple #9
0
    def __recover_file(self, path):

        import mimetypes

        name = os.path.split(path)[1]

        details = calculate_details(path)
        streams = self.lookup_streams_by_details(*details)

        if (len(streams) == 0):
            return False

        if (not streams[0]._verify()):
            self.imgdb.load_data(path, streams[0].stream.stream_id,
                                 streams[0].stream.priority,
                                 streams[0].stream.extension)

            ext = os.path.splitext(path)[1]
            assert ext[0] == '.'
            streams[0].stream.extension = ext[1:]
            streams[0].stream.mime_type = mimetypes.guess_type(path,
                                                               strict=False)[0]
        return True
Exemple #10
0
    def __register_thumb(self, path, obj, origin, name):

        import mimetypes

        ext = os.path.splitext(path)[1]
        assert ext[0] == '.'
        ext = ext[1:]

        details = calculate_details(path)
        mime_type = mimetypes.guess_type(path, strict=False)[0]

        stream = model.Stream(obj.obj, name, model.SP_EXPENDABLE,
                              origin.stream, ext, mime_type)
        stream.set_details(*details)
        self.session.add(stream)

        log = model.StreamLog(stream, 'imgdb:' + name, origin.stream, None)
        self.session.add(log)
        self.session.flush()

        self.imgdb.load_data(path, stream.stream_id, stream.priority,
                             stream.extension)

        return model_stream_to_higu_stream(self, stream)