Feature/registry package index (#2623)

* include system images in compat s9pk

* wip

* wip

* update types

* wip

* fix signature serialization

* Add SignatureHeader conversions

* finish display impl for get

---------

Co-authored-by: Shadowy Super Coder <musashidisciple@proton.me>

core/startos/src/util/io.rs

@@ -1,4 +1,4 @@
-use std::collections::VecDeque;
+use std::collections::{BTreeSet, VecDeque};
 use std::future::Future;
 use std::io::Cursor;
 use std::os::unix::prelude::MetadataExt;
@@ -19,7 +19,7 @@ use tokio::io::{
     duplex, AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, DuplexStream, ReadBuf, WriteHalf,
 };
 use tokio::net::TcpStream;
-use tokio::sync::Notify;
+use tokio::sync::{Notify, OwnedMutexGuard};
 use tokio::time::{Instant, Sleep};
 
 use crate::prelude::*;
@@ -804,7 +804,7 @@ pub struct TeeWriter<W1, W2> {
     #[pin]
     writer2: W2,
 }
-impl<W1: AsyncWrite, W2: AsyncWrite> TeeWriter<W1, W2> {
+impl<W1, W2> TeeWriter<W1, W2> {
     pub fn new(writer1: W1, writer2: W2, capacity: usize) -> Self {
         Self {
             capacity,
@@ -815,7 +815,6 @@ impl<W1: AsyncWrite, W2: AsyncWrite> TeeWriter<W1, W2> {
         }
     }
 }
-
 impl<W1: AsyncWrite + Unpin, W2: AsyncWrite + Unpin> TeeWriter<W1, W2> {
     pub async fn into_inner(mut self) -> Result<(W1, W2), Error> {
         self.flush().await?;
@@ -1007,3 +1006,114 @@ impl AsyncWrite for ParallelBlake3Writer {
         Poll::Pending
     }
 }
+
+#[pin_project::pin_project]
+pub struct TrackingIO<T> {
+    position: u64,
+    #[pin]
+    io: T,
+}
+impl<T> TrackingIO<T> {
+    pub fn new(start: u64, io: T) -> Self {
+        Self {
+            position: start,
+            io,
+        }
+    }
+    pub fn position(&self) -> u64 {
+        self.position
+    }
+    pub fn into_inner(self) -> T {
+        self.io
+    }
+}
+impl<W: AsyncWrite> AsyncWrite for TrackingIO<W> {
+    fn poll_write(
+        self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+        buf: &[u8],
+    ) -> std::task::Poll<Result<usize, std::io::Error>> {
+        let this = self.project();
+        let written = futures::ready!(this.io.poll_write(cx, buf)?);
+        *this.position += written as u64;
+        Poll::Ready(Ok(written))
+    }
+    fn poll_flush(
+        self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Result<(), std::io::Error>> {
+        self.project().io.poll_flush(cx)
+    }
+    fn poll_shutdown(
+        self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Result<(), std::io::Error>> {
+        self.project().io.poll_shutdown(cx)
+    }
+}
+impl<R: AsyncRead> AsyncRead for TrackingIO<R> {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<std::io::Result<()>> {
+        let this = self.project();
+        let start = buf.filled().len();
+        futures::ready!(this.io.poll_read(cx, buf)?);
+        *this.position += (buf.filled().len() - start) as u64;
+        Poll::Ready(Ok(()))
+    }
+}
+impl<T> std::cmp::PartialEq for TrackingIO<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.position.eq(&other.position)
+    }
+}
+impl<T> std::cmp::Eq for TrackingIO<T> {}
+impl<T> std::cmp::PartialOrd for TrackingIO<T> {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        self.position.partial_cmp(&other.position)
+    }
+}
+impl<T> std::cmp::Ord for TrackingIO<T> {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.position.cmp(&other.position)
+    }
+}
+impl<T> std::borrow::Borrow<u64> for TrackingIO<T> {
+    fn borrow(&self) -> &u64 {
+        &self.position
+    }
+}
+
+pub struct MutexIO<T>(OwnedMutexGuard<T>);
+impl<R: AsyncRead + Unpin> AsyncRead for MutexIO<R> {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<std::io::Result<()>> {
+        Pin::new(&mut *self.get_mut().0).poll_read(cx, buf)
+    }
+}
+impl<W: AsyncWrite + Unpin> AsyncWrite for MutexIO<W> {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+        buf: &[u8],
+    ) -> Poll<Result<usize, std::io::Error>> {
+        Pin::new(&mut *self.get_mut().0).poll_write(cx, buf)
+    }
+    fn poll_flush(
+        self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> Poll<Result<(), std::io::Error>> {
+        Pin::new(&mut *self.get_mut().0).poll_flush(cx)
+    }
+    fn poll_shutdown(
+        self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> Poll<Result<(), std::io::Error>> {
+        Pin::new(&mut *self.get_mut().0).poll_shutdown(cx)
+    }
+}