removed recvfile

Author: rahulrangers

io/jvm/src/main/scala/fs2/io/net/SelectingSocket.scala

@@ -105,33 +105,6 @@ private final class SelectingSocket[F[_]: LiftIO] private (
     case _ =>
       super.sendfile(file, offset, count, chunkSize)
   }
-
-  override def recvfile(
-      file: FileHandle[F],
-      offset: Long,
-      count: Long,
-      chunkSize: Int
-  ): Stream[F, Nothing] = file match {
-    case syncFileHandle: SyncFileHandle[F] =>
-      val fileChannel = syncFileHandle.chan
-
-      def go(currOffset: Long, remaining: Long): F[Unit] =
-        if (remaining <= 0) F.unit
-        else {
-          F.blocking(fileChannel.transferFrom(ch, currOffset, remaining)).flatMap { readBytes =>
-            if (readBytes > 0) {
-              go(currOffset + readBytes, remaining - readBytes)
-            } else {
-              selector.select(ch, OP_READ).to *> go(currOffset, remaining)
-            }
-          }
-        }
-
-      Stream.eval(readMutex.lock.surround(go(offset, count))).drain
-
-    case _ =>
-      super.recvfile(file, offset, count, chunkSize)
-  }
 }
 
 private object SelectingSocket {

io/jvm/src/main/scala/fs2/io/net/unixsocket/UnixSocketsPlatform.scala

@@ -161,31 +161,5 @@ private[unixsocket] trait UnixSocketsCompanionPlatform {
         super.sendfile(file, offset, count, chunkSize)
     }
 
-    override def recvfile(
-        file: FileHandle[F],
-        offset: Long,
-        count: Long,
-        chunkSize: Int
-    ): Stream[F, Nothing] = file match {
-      case syncFileHandle: SyncFileHandle[F] =>
-        val fileChannel = syncFileHandle.chan
-
-        def go(currOffset: Long, remaining: Long): F[Unit] =
-          if (remaining <= 0) F.unit
-          else {
-            F.blocking(fileChannel.transferFrom(ch, currOffset, remaining)).flatMap { readBytes =>
-              if (readBytes == 0) F.unit
-              else {
-                go(currOffset + readBytes, remaining - readBytes)
-              }
-            }
-          }
-
-        Stream.eval(readMutex.lock.surround(go(offset, count))).drain
-
-      case _ =>
-        super.recvfile(file, offset, count, chunkSize)
-    }
-
   }
 }

io/shared/src/main/scala/fs2/io/net/Socket.scala

@@ -98,37 +98,6 @@ trait Socket[F[_]] {
 
     go(offset, count).through(writes)
   }
-
-  /** Reads from a socket and writes to a file.
-    * Streams the socket data of the specified size and writes them to the file.
-    * The stream terminates when the socket signals end of input or the specified count is reached.
-    *
-    * @param file the file handle to write to
-    * @param offset the starting position in the file
-    * @param count the maximum number of bytes to transfer
-    * @param chunkSize the size of each chunk to read
-    */
-  def recvfile(
-      file: FileHandle[F],
-      offset: Long,
-      count: Long,
-      chunkSize: Int
-  ): Stream[F, Nothing] = {
-
-    def go(currOffset: Long, remaining: Long): Stream[F, Nothing] =
-      if (remaining > 0)
-        Stream.eval(read(math.min(remaining, chunkSize.toLong).toInt)).flatMap {
-          case Some(chunk) if chunk.nonEmpty =>
-            Stream.eval(file.write(chunk, currOffset)) >> go(
-              currOffset + chunk.size,
-              remaining - chunk.size
-            )
-          case _ => Stream.empty
-        }
-      else Stream.empty
-
-    go(offset, count)
-  }
 }
 
 object Socket extends SocketCompanionPlatform

io/shared/src/test/scala/fs2/io/net/tcp/SocketSuite.scala

@@ -325,47 +325,6 @@ class SocketSuite extends Fs2Suite with SocketSuitePlatform {
           assertEquals(received, expected)
         }
     }
-    test("recvfile - send data from socket to file from the offset") {
-      val content = "Hello, world!"
-      val offset = 0L
-      val count = 5L
-      val expected = "Hello"
-      val chunkSize = 2
-
-      val setup = for {
-        tempFile <- Files[IO].tempFile
-        serverSetup <- Network[IO].serverResource(Some(ip"127.0.0.1"))
-        (bindAddress, server) = serverSetup
-        client <- Network[IO].client(bindAddress)
-      } yield (tempFile, server, client)
-
-      Stream
-        .resource(setup)
-        .flatMap { case (tempFile, server, client) =>
-          val serverStream = server.head.flatMap { socket =>
-            Stream.eval(socket.write(Chunk.array(content.getBytes))) >>
-              Stream.eval(socket.endOfOutput)
-          }
-
-          val clientStream =
-            Stream.resource(Files[IO].open(tempFile, Flags.Write)).flatMap { fileHandle =>
-              client.recvfile(fileHandle, offset, count, chunkSize).drain
-            }
-
-          val checkFile = Files[IO]
-            .readAll(tempFile, chunkSize, Flags.Read)
-            .through(text.utf8.decode)
-            .compile
-            .string
-
-          clientStream.concurrently(serverStream).drain ++ Stream.eval(checkFile)
-        }
-        .compile
-        .lastOrError
-        .map { received =>
-          assertEquals(received, expected)
-        }
-    }
 
   }
 }