Hi wybiral! I saw your awesome project on GitHub, and works well. I want to add Docker support for this project, so I add Dockerfile and build an image on my Arch Linux machine, it works well.

but I change a huge amount of files.

1 I make a new dir call config, and move config.json to this dir, so user can use custom config.json override default when using docker container with -v /path/to/your/own/config.json:/container/default/config.json

2 I remove vendor dir, when I clone this repo, execute go mod init go mod tidy, I can run go build -o tube . without error in project root directory. I'm a newbee in golang, correct me how can I build tube without remove vendor dir

Don't release an official v0.0.1 until this thing is better documented. Both in terms of README and in terms of code comments.

This should be the last thing done before v0.0.1 and will probably involve a general code review to catch any missing documentation and to make sure the behavior is consistent with the docs.

An RSS feed should be generated from the scanned files and provided at some endpoint (maybe /feed.xml). Even better if it supports JSON feeds too (/feed.json).

Most likely implementation: https://github.com/gorilla/feeds

Having to restart the server to update the library is really annoying and it would interrupt any streams currently playing. Here are some possibilities:

• Watch the videos directory for file changes and update (best)
• Provide a way to force an update on demand
• Update at a configurable interval

Requiring a proper Go environment setup is messy and not user friendly at all. The solution will be to build the project as a zip archive for each platform containing the relative static files and binary application.

This will probably be done with a Python script.

Errors like #15 should be more clear about why they're happening. In that case it was because the Tor controller port wasn't open so the application should notify the user about this and possibly recommend a solution (disable Tor or check the daemon, in this case).

Currently the RSS feed is generated every time it's requested. That's pretty wasteful if people are requesting the feed at some frequency, especially if there are a lot of videos in the library. It would be best to only build the feed after the library changes.

It's probably easiest to move the feed generating portion into the Library type. It is a feed of the library, after all. Otherwise we'd need some kind of messaging to trigger the outside components when the library is changed.

If no explicit external_url or link values are supplied in config.json and you run the server as a Tor onion service the server should plug in the onion address for those values.

This will make it easier to subscribe from RSS readers through a Tor proxy without any setup from a hosting perspective.

Add the following (optional) structure to config.json:

"tor": {
  "onion_file": "/path/to/key/file",
  "controller": {
    "host": "127.0.0.1",
    "port": 9051
  }
}

If it exists the server will start a Tor hidden service using the onion key file routed to the local host:port TCP server. If the tor structure is in the config file but onion_file is blank a random onion will be generated.

To make things even smoother, when the external_url property of feed is blank it can be filled with the onion address.

This will make it easy to publish content on Tor in a way that RSS readers can subscribe to and remotely access.

Outside the scope of this project: if someone implemented a Tor proxied feed reader into the backend of this you could build a YouTube-like application where people could subscribe to peer videos and host their own. Just an idea.

Currently the watcher is working overtime while a large file is being copied into the library because every flush during the copy triggers a write event in fsnotify which results in a bunch of unnecessary Library.Remove & Library.Add calls.

This can be fixed by debouncing the watcher so that events don't cause an action on a specific path until a fixed amount of time passes with no events. It may even be optimal to just accumulate all changes to the library and perform them in batch after a reasonable debounce time.

It would be useful to support multiple library paths instead of just one. Something like this in the config.json file:

{
  "libraries": [
    {"path": "/path/to/season01", "prefix": "s01"},
    {"path": "/path/to/season02", "prefix": "s02"}
  ]
}

The prefixes will be included in the URL paths, so you might have /v/s01/e01 and so on. This will ensure that all names are unique across multiple library paths and allow for some hierarchical structuring.

Using "prefix" as the key may be too ambiguous though. Consider using "name" or "id" or something.

One question this opens is how to visually convey the path difference in the UI. Especially in the sidebar video selection. Could be another line like the modified field?

Hi: I want to know how many people can access this system at the same time on the premise that the network bandwidth is not a problem? After the deployment of the intranet, I found that the response speed of about 6 or 7 simultaneous accesses became very slow or even stuck. Is there any optimization method?

Hey,

1）about config.json When I try to run tube as a service under ubuntu 16 tls , tube can't load the config.json file automatic,but it can work well under command line in the tube folder. how about add a function like -c /path/config.json ?

2. If organize videos with folders ,will tube support it ?

best regards

Hi wybiral I add a Dockerfile to make this project able to run in container. to mount a config.json file from host machine, I change the project structure, move config.json to config dir. and, I also update the README.md

thanks!