Extract filename from io.ReadCloser

Question

I need to get the filename of certain file(s) that receives backend from the frontend. Backend (implemented in Go) will receive the file as io.ReadCloser. Is there way I could extract it from the io.ReadCloser?

Answer 1

Backend (implemented in Go) will receive the file as io.ReadCloser. Is there way I could extract it from the io.ReadCloser?

No.

Take a look at which methods an io.ReadCloser provides by running go doc io.ReadCloser and note that there isn't a method which will provide a name. So unless you know nothing more that that it is an io.ReadCloser you simply cannot do it.

Answer 2

package main

import (
    "errors"
    "fmt"
    "io"
    "os"
)

func fatalln(err error) {
    fmt.Fprintln(os.Stderr, err)
    os.Exit(1)
}

// hasName interface is an interface that expects types
// that implements it to have "Name() string" method.
type hasName interface {
    Name() string
}

func open(name string) (io.ReadCloser, error) {
    f, err := os.Open(name)
    if err != nil {
        return nil, err
    }
    // f implements io.ReadCloser interface as *os.File
    // has Read and Close methods.
    return f, nil
}

func main() {
    // rc is of the type io.ReadCloser
    rc, err := open("example.txt")
    if err != nil {
        fatalln(err)
    }
    defer rc.Close()

    // Type assetion to check rc's underlying type has
    // a method "Name() string".
    f, ok := rc.(hasName)
    if !ok {
        fatalln(errors.New("type assertion failed"))
    }

    // Yay, type assertion succeeded. Print the name!
    fmt.Println("Name:", f.Name())
}

Answer 3

The io.ReadCloser here is a reader for runtime reader which reads file from network as the frontend sends it to backend. You'll have to work on request itself to get that file name. This is an assumption but in most such cases for file upload, the request is a multipart request. If you have the same situation, you can read the headers, typically Content-Disposition to identify the file type. Go native http.Request has ability to parse the details. You can try this :

formFile, handler, err := r.FormFile("file")  // read file from network with key "file"
defer formFile.Close()

fileName := handler.Filename // Get file name

Answer 4

By defining an interface which embeds io.Reader you can require a Name() method up front:

package main

import (
    "fmt"
    "io"
    "log"
    "os"
)

type NamedReadCloser interface {
    io.ReadCloser
    Name() string
}

func doThings(f NamedReadCloser) error {
    defer f.Close()
    b, err := io.ReadAll(f)
    if err != nil {
        return err
    }
    fmt.Printf("Name: %s, Content: %s\n", f.Name(), b)
    return nil
}

func main() {
    f, err := os.Open("/etc/hosts")
    if err != nil {
        log.Fatal("Cannot open file: ", err)
    }
    err = doThings(f)
    if err != nil {
        log.Fatal("Error doing things: ", err)
    }
}

This will only work if what is passed in has a name method, like an *os.File. If it does not, then what you are trying to do is not possible.

Answer 5

You'll have to cast it to a type with a Name method:

package main

import (
   "io"
   "os"
)

func open(name string) (io.ReadCloser, error) {
   return os.Open(name)
}

func main() {
   c, e := open("file.txt")
   if e != nil {
      panic(e)
   }
   defer c.Close()
   f := c.(*os.File)
   println(f.Name())
}