Beispiel #1
0
def do_migration(conf):
    db_path = os.path.join(conf.data_dir, "lbrynet.sqlite")
    blob_dir = os.path.join(conf.data_dir, "blobfiles")
    connection = sqlite3.connect(db_path)
    cursor = connection.cursor()

    query = "select stream_name, stream_key, suggested_filename, sd_hash, stream_hash from stream"
    streams = cursor.execute(query).fetchall()

    blobs = cursor.execute(
        "select s.stream_hash, s.position, s.iv, b.blob_hash, b.blob_length from stream_blob s "
        "left outer join blob b ON b.blob_hash=s.blob_hash order by s.position"
    ).fetchall()
    blobs_by_stream = {}
    for stream_hash, position, iv, blob_hash, blob_length in blobs:
        blobs_by_stream.setdefault(stream_hash, []).append(
            BlobInfo(position, blob_length or 0, iv, blob_hash))

    for stream_name, stream_key, suggested_filename, sd_hash, stream_hash in streams:
        sd = StreamDescriptor(asyncio.get_event_loop(), blob_dir, stream_name,
                              stream_key, suggested_filename,
                              blobs_by_stream[stream_hash], stream_hash,
                              sd_hash)
        if sd_hash != sd.calculate_sd_hash():
            log.warning("Stream for descriptor %s is invalid, cleaning it up",
                        sd_hash)
            blob_hashes = [
                blob.blob_hash for blob in blobs_by_stream[stream_hash]
            ]
            delete_stream(cursor, stream_hash, sd_hash, blob_hashes, blob_dir)

    connection.commit()
    connection.close()
Beispiel #2
0
 async def store_fake_stream(self,
                             stream_hash,
                             blobs=None,
                             file_name="fake_file",
                             key="DEADBEEF"):
     blobs = blobs or [BlobInfo(1, 100, "DEADBEEF", random_lbry_hash())]
     descriptor = StreamDescriptor(asyncio.get_event_loop(), self.blob_dir,
                                   file_name, key, file_name, blobs,
                                   stream_hash)
     sd_blob = await descriptor.make_sd_blob()
     await self.storage.store_stream(sd_blob, descriptor)
     return descriptor
Beispiel #3
0
 def get_stream_descriptor(self, sd_hash):
     return StreamDescriptor.from_stream_descriptor_blob(
         self.loop, self.blob_dir, self.get_blob(sd_hash))