aschmahmann changed the topic of #ipfs to: Heads Up: To talk, you need to register your nick! Announcements: go-ipfs 0.7.0 and js-ipfs 0.52.3 are out! Get them from dist.ipfs.io and npm respectively! | Also: #libp2p #ipfs-cluster #filecoin #ipfs-dev | IPFS: https://github.com/ipfs/ipfs | Logs: https://view.matrix.org/room/!yhqiEdqNjyPbxtUjzm:matrix.org/ | Forums: https://discuss.ipfs.io | Code of Conduct: https://git.io/vVBS0
spinza has joined #ipfs
jessehattabaugh has joined #ipfs
hurikhan77 has quit [Ping timeout: 272 seconds]
joey has quit [Remote host closed the connection]
hurikhan77 has joined #ipfs
alessandroCetera has joined #ipfs
Martin[m]8 has left #ipfs ["User left"]
joey has joined #ipfs
chiui has quit [Ping timeout: 260 seconds]
deltab has quit [Ping timeout: 256 seconds]
ipfs-stackbot has quit [Remote host closed the connection]
ipfs-stackbot has joined #ipfs
deltab has joined #ipfs
royal_screwup21 has quit [Quit: Connection closed]
royal_screwup21 has joined #ipfs
digitalnomad91__ has joined #ipfs
epony has joined #ipfs
jessehattabaugh_ has joined #ipfs
epony has left #ipfs ["PART"]
jessehattabaugh has quit [Ping timeout: 240 seconds]
digitalnomad91_ has quit [Ping timeout: 264 seconds]
xentec has quit [Quit: memento mori]
xentec has joined #ipfs
royal_screwup21 has quit [Quit: Connection closed]
royal_screwup21 has joined #ipfs
jesse22 has quit [Ping timeout: 240 seconds]
hurikhan77 has quit [Ping timeout: 272 seconds]
royal_screwup21 has quit [Ping timeout: 264 seconds]
Nact has quit [Quit: Konversation terminated!]
samamy[m] has left #ipfs ["User left"]
<concernedanon10>
Hey, so I'm kinda confused. Who hosts the IPFS hashes? If I host something on IPFS, where does the hash get posted to so that it's searchable?
<concernedanon10>
i.e. if I enter an IPFS address, how does my node know where to look in order to access that information?
f[x] has quit [Remote host closed the connection]
arcatech has quit [Quit: Be back later.]
alessandroEtc has joined #ipfs
alessandroCetera has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
alessandroEtc has quit [Client Quit]
arcatech has joined #ipfs
f[x] has joined #ipfs
pecastro has quit [Ping timeout: 264 seconds]
}ls{ has quit [Ping timeout: 246 seconds]
}ls{ has joined #ipfs
royal_screwup21 has joined #ipfs
royal_screwup21 has quit [Ping timeout: 256 seconds]
jessehattabaugh_ has quit [Ping timeout: 240 seconds]
jessehattabaugh_ has joined #ipfs
jcea has joined #ipfs
ipfs-stackbot1 has quit [Remote host closed the connection]
ipfs-stackbot has joined #ipfs
jcea has quit [Quit: jcea]
jcea has joined #ipfs
jmsx has joined #ipfs
digitalnomad91_ has joined #ipfs
jmsx_ has quit [Ping timeout: 264 seconds]
Forkk has quit [Ping timeout: 264 seconds]
Forkk_ has joined #ipfs
digitalnomad91__ has quit [Ping timeout: 272 seconds]
KeiraT has quit [Remote host closed the connection]
KeiraT has joined #ipfs
zeden has quit [Quit: WeeChat 3.0]
<Discordian[m]>
Couple questions:
<Discordian[m]>
I added a directory with ~18k files using `ipfs add -r <dir>`. The directory doesn't show up in `ipfs ls` though, did I miss something?
<Discordian[m]>
I've added the directory to IPNS (k51qzi5uqu5dgsg9h4kk0hi8tgztxjbtjoalctv4x28hdzpiag1xxzx7dpnew2). If I want to update the directory do I need to re-add every file? What I was going to do is update the files on IPFS, and then re-run `ipfs name publish <CID>` for the new CID, but now I'm unsure if that makes sense.
<Discordian[m]>
I don't mind if I have to re-add the entire directory each time. Just trying to get a better understanding of the flow.
royal_screwup21 has quit [Quit: Connection closed]
royal_screwup21 has joined #ipfs
<Discordian[m]>
It looks like I do. That's fine. Narrowing down my questions to:
<Discordian[m]>
1. Do I need a new IPNS key for each directory I want to publish?
<Discordian[m]>
2. Why doesn't my directory show up in `ipfs ls`?
<Discordian[m]>
Super fun, I love that it's working at least.
alessandroEtc has joined #ipfs
<Discordian[m]>
* It looks like I do. That's fine. Narrowing down my questions to:
<Discordian[m]>
1. Do I need a new IPNS key for each directory I want to publish? (I think yes is the answer)
<Discordian[m]>
2. Why doesn't my directory show up in `ipfs ls`?
Malin has joined #ipfs
Malin has left #ipfs [#ipfs]
MDude has joined #ipfs
bmwiedemann1 has joined #ipfs
MalinC has joined #ipfs
bmwiedemann1 has quit [Ping timeout: 246 seconds]
<Discordian[m]>
* It looks like I do. That's fine. Narrowing down my questions to:
<Discordian[m]>
2. Why doesn't my directory show up in `ipfs files ls`?
<Discordian[m]>
1. Do I need a new IPNS key for each directory I want to publish? (I think yes is the answer)
<Discordian[m]>
* Couple questions:
<Discordian[m]>
I've added the directory to IPNS (k51qzi5uqu5dgsg9h4kk0hi8tgztxjbtjoalctv4x28hdzpiag1xxzx7dpnew2). If I want to update the directory do I need to re-add every file? What I was going to do is update the files on IPFS, and then re-run `ipfs name publish <CID>` for the new CID, but now I'm unsure if that makes sense.
<Discordian[m]>
I added a directory with ~18k files using `ipfs add -r <dir>`. The directory doesn't show up in `ipfs files ls` though, did I miss something?
KeiraT has quit [Remote host closed the connection]
<Discordian[m]>
Haha I've been messing with it all morning, burned in for now
<swedneck>
<Discordian[m] "Without the auto-sync I'll be wr"> what about the auto-sync broke?
<jamiew>
thanks; specifically the --key option here, right?
<Discordian[m]>
It only synced the first 800MB
<swedneck>
huh
<Discordian[m]>
"First" was a bit random too, random files didn't make it
<Discordian[m]>
1.2GB of them
<Discordian[m]>
Yeah I couldn't figure out how to make it work again, removing the new files (down to just over 1MB) fixed it, and it started syncing properly again
<swedneck>
jamiew: yeah you give the ipns key a name when generating it, then you refer to that with the --key flag
bmwiedemann1 has joined #ipfs
<jamiew>
thanks, appreciate the pointer
<Discordian[m]>
The HTTP API looks dead simple too, so getting used to these commands should allow me to make a CLI application for auto-syncing.
tsrt^ has quit []
<swedneck>
pretty sure the http api is basically the same as the CLI api but in http formal lol
<swedneck>
* pretty sure the http api is basically the same as the CLI api but in http format lol
<alessandroEtc>
I have a loaded question for the group here: If IPFS offers a distributed network to store files, how can one efficiently update a file and have that change propagate through the network? A basic example would be, say two people on opposite ends of the world find a typo on a wikipedia page and fix it. How would the system handle this? Are the two
<alessandroEtc>
sides of the world seeing pages fixed by different people?
<Discordian[m]>
Yeah it is lol, complete with curl examples in the docs
<swedneck>
ipfs is not a network to store files
<Discordian[m]>
IPFS files are immutable so if 2 people made a change and published them, there'd be 3 versions (unless deduplication kicks in, then 2 versions)
<swedneck>
basically think of it as torrent, most of what applies there applies here
shah^ has joined #ipfs
<swedneck>
to make a fully functioning wikipedia on ipfs you need to build a layer ontop of ipfs, so ipfs itself wouldn't really care about people editing the wikipedia, the layer ontop of ipfs would be what handles edit conflicts
<Discordian[m]>
That'd be an interesting scheme lol
<alessandroEtc>
@swedneck yeah, that's what i was thinking
<alessandroEtc>
something that handles collisions
<swedneck>
it's like how the HTTP protocol doesn't care what you do on a website, the website server is what actually handles things
<swedneck>
ipfs itself doesn't even have collisions
<Discordian[m]>
Curious, what's `ipfs pin update <from-path> <to-path>` for? Will that unpin my old CID, and pin to the new one?
<swedneck>
have you read the docs?
<Discordian[m]>
Might be looking at the wrong docs, I only see `Update a recursive pin`
<Discordian[m]>
MFS is really useful in this instance as I don't need to re-add the entire directory (letting deduplication handle the rest lol)
<Discordian[m]>
Alright, gonna try to make this clean so I can release open-source. It should be literally the same as the syncing pyramid feature of galacteek, but with almost no moving parts. It'll do just this one thing.
<swedneck>
maybe check the galacteek source to see if you can just rip the relevant code out
<swedneck>
it's just python
justanotherdude has quit [Quit: RAGEQUIT]
<Discordian[m]>
Good point, I'll give it a glance. I'll likely write my software in Go though
<swedneck>
fair enough
<swedneck>
could maybe make it a go-ipfs plugin
<Discordian[m]>
Oooh it supports plugins? Yeah, that sounds ideal
justanotherdude has joined #ipfs
justanotherdude has quit [Remote host closed the connection]
<Discordian[m]>
It appears the GUI and the working code is one, resulting in the Pyramid code being 1700 lines. I think the idea is simple enough to start from scratch.
aLeSD has quit [Quit: Leaving]
bcowing has joined #ipfs
n1v has joined #ipfs
Adbray has quit [Remote host closed the connection]
Adbray has joined #ipfs
niv has quit [Ping timeout: 246 seconds]
<Discordian[m]>
Thanks for that link. I think a plugin is a good secondary goal. Only because the API is different enough that I need to do some more reading. Also having both as an option would probably be nice anyways in case someone isn't using `go-ipfs` (assuming the HTTP API is more-or-less the same across the daemons)
<Discordian[m]>
Looks like `ipfs files write` avoids `ipfs add` altogether (probably does it automatically)
f[x] has joined #ipfs
l_o[m] has quit [Quit: Idle for 30+ days]
testggfdgdf[m] has quit [Quit: Idle for 30+ days]
miceiken[m] has quit [Quit: Idle for 30+ days]
arcatech has joined #ipfs
LiftLeft has joined #ipfs
royal_screwup21 has quit [Quit: Connection closed]
fcktheworld587[m is now known as Garbaldo[m]
matt-h has quit [Ping timeout: 264 seconds]
matt-h has joined #ipfs
nnm has joined #ipfs
basedgod has joined #ipfs
arcatech has quit [Quit: Bye.]
gmoro has quit [Remote host closed the connection]
bmwiedemann1 has quit [Remote host closed the connection]
Ringtailed_Fox has joined #ipfs
Ringtailed-Fox has quit [Read error: Connection reset by peer]
Newami has quit [Quit: Leaving]
bengates has quit [Ping timeout: 256 seconds]
sz0 has quit [Quit: Connection closed for inactivity]
jesse22 has joined #ipfs
MalinC has quit [Ping timeout: 264 seconds]
deprecated has quit [Quit: Leaving]
codepy69 has quit [Quit: Quit..]
codepy69 has joined #ipfs
codepy69 has quit [Changing host]
codepy69 has joined #ipfs
jrt has quit [Changing host]
jrt has joined #ipfs
jesse22 has quit [Ping timeout: 265 seconds]
bengates has joined #ipfs
jesse22 has joined #ipfs
MalinC has joined #ipfs
concernedanon10 has quit [Read error: Connection reset by peer]
concernedanon10 has joined #ipfs
bengates has quit [Ping timeout: 240 seconds]
jessehattabaugh_ has quit [Quit: Leaving]
concernedanon10 has quit [Read error: Connection reset by peer]
concernedanon10 has joined #ipfs
concernedanon10 has quit [Client Quit]
alessandroEtc has joined #ipfs
duh_luckless[m] has joined #ipfs
<duh_luckless[m]>
Ahoy - I could use a touch of advice. I'm on the hunt for a piece of golang code that shows 1) starting the ipfs daemon and 2) reading a file. I'm hoping to accomplish both the same binary. If you've seen something like that I'd much appreciate knowing!
<duh_luckless[m]>
* Ahoy - I could use a touch of advice. I'm on the hunt for a piece of golang code that shows 1) starting the ipfs daemon and 2) reading a file from ipfs. I'm hoping to accomplish both the same binary. If you've seen something like that I'd much appreciate knowing!
<Discordian[m]>
If you plan on using the local ipfs daemon (expecting go-ipfs is installed), you could rely on systemd to start the service. For accessing the API, you can use HTTP, which is super simple, and functions nearly identically to the CLI commands.
<duh_luckless[m]>
Thanks Discordian
<duh_luckless[m]>
Indeed....though, if I can, I'd like to start and stop the daemon from native golang (wihtout callinjg another process)
<duh_luckless[m]>
Alternative, I'm curious if it's possoble to fetch a file w/o the daemon
<Discordian[m]>
Ah, I always rely on systemd, as most Linux distros have it, and it's the most "kosher" way to handle a service on a distro with systemd
<Discordian[m]>
Yeah you could use libp2p I believe to access IPFS w/o a local daemon
<duh_luckless[m]>
orly
<Discordian[m]>
Yeah things like hardbin.com seem to work like that
<Discordian[m]>
Or you connect to a global node, and just use that.
<duh_luckless[m]>
Oh, there are public nodes to which one can connect w/ the Http api?
<duh_luckless[m]>
(Sorry, I'm new to this...)
<Discordian[m]>
Judging by docs, I get that impression. I'm also new though, and I've been crash coursing it
<Discordian[m]>
(started yesterday)
<Discordian[m]>
Yeah looks like any public gateway should be fine, but if you want to write, it needs to be a writeable gateway
GvP has quit [Read error: Connection reset by peer]
<Discordian[m]>
No problem, hope it saves precious time :)
miceiken has joined #ipfs
DuCheng[m] has joined #ipfs
f[x] has quit [Remote host closed the connection]
f[x] has joined #ipfs
awakecoding has joined #ipfs
theseb has joined #ipfs
<theseb>
Why does ipfs app use Go? Is it somehow better for ipfs than Python?
<swedneck>
what specific program do you mean?
<theseb>
swedneck: well for one thing...I interviewed for a job at Protocol Labs....they wanted Go programmers
<swedneck>
regardless though, go is a compiled language which is almost always better for performance, and since it complies to a single file it's easier to install
<theseb>
They wanted a liason to help ipfs devs with their Go code
<theseb>
They seemed to assume everyone and their brother was coding cool ipfs stuff in Go
<swedneck>
go is just the language that protocol labs likes, i suppose
<swedneck>
you can absolutely write ipfs stuff in whatever language you like, there's a rust implementation for example, but organizations will prefer to use the same language for everything they make since that makes everything easier to deal with
decentralized has joined #ipfs
<Discordian[m]>
For a daemon like ipfs Go is a way better choice over Python because you don't have to deal with nasty stuff like the GIL.
<swedneck>
that too
<Discordian[m]>
BTW my syncing tool works better than expected so far. Doing it slow and steady, but the IPFS devs have made this a breeze 🙂.
<Discordian[m]>
I think I'm going to make it auto-unpin on delete too, might as well.
<theseb>
Discordian[m]: is the GIL mainly a problem if you have lots of threads? What if you use something like the reactor pattern (e.g. Twisted, asyncio, etc.)
<swedneck>
you still have the issue of distribution
<swedneck>
with go you just compile some binaries for different architectures and that's about it
<Discordian[m]>
You can work around the problem, but yeah exactly that, it's hard to get Python to fully use a system's resources in Go it's literally just `go function()` done.
bcowing has quit [Ping timeout: 272 seconds]
<theseb>
interesting...thanks
<Discordian[m]>
Anytime 🙂. (Disclaimer: Python is awesome, I just don't think it's a good choice for heavy things or servers)
<theseb>
swedneck: wait..by "distribution" you just mean "portability"?....Python runs in a VM so is automatically portable
<theseb>
swedneck: like Java/JVM no?
<Discordian[m]>
Well python is interpreted, so it's very portable. It's lighter than the JVM
<Discordian[m]>
I thought by distribution you meant "distribution of resources", because I'd 100% agree, looking at how Synapse handles the problem has me like "...why wouldn't you just ditch Python at that point?"
<theseb>
Discordian[m]: if i can say one more thing...
<theseb>
Discordian[m]: Python allows you to replace bottlenecks with C extensions
<theseb>
Discordian[m]: so between avoiding threads and carefully sprinking in a little C...seems it should be a good competitor to Go?
<swedneck>
then you're dealing with 2 languages instead of one
<swedneck>
don't get me wrong, i can basically only write python, but it's just not the right tool for the job
<theseb>
Discordian[m]: (disclaimer: i'm too lazy to learn a new lang so I'm desperately hoping you'll convince me Python is 'just as good')
<Discordian[m]>
I mean, one of Go's massive benefits is the simplicity. You're not going to get anywhere near the simplicity of Go using that setup. Honestly Go is so easy to learn coming from Python/C, it might be worth a go. Also Go's goroutines aren't just threads, so you get the added value of easy concurrency that will use threads if they're available, and automatically offload resources to other threads when they're busy.
<swedneck>
oh yeah python is also a pain on windows since it doesn't have a python interpreter by default
<Discordian[m]>
It's just not that simple to compete. However I will say, C and Python are capable of being just as powerful, if you want to go through all the pain of accomplishing it that is. C is undoubtably able to outperform Go, but you're not going to accomplish it easily for a large project.
<Discordian[m]>
That too, Windows as a target, not as easy to redistribute
<swedneck>
also embedded stuff, which ipfs might be used for
<Discordian[m]>
However in Go, it cross compiles like it's nothing, and is super simple
<Discordian[m]>
There is micropython, but I'm not sure Go is actually ideal for embedded
<theseb>
Discordian[m]: if you think Go is simple that's a good sign
<Discordian[m]>
That's one of Go's major goals/philosophies. Simplicity, and readability.
<theseb>
On another topic....I was blown away when I found out d.tube (decentralized YouTube competitor) used IPFS and blockchain...I think that is really exciting and possibly a real killer app for ipfs
<Discordian[m]>
This page is what got me hooked, if you keep going through the arrows, you'll learn a lot without ever installing anything: https://tour.golang.org/welcome/1
<theseb>
is everyone else as excited about d.tube? I think ipfs + blockchain is a powerful combo I'd like to see more of
<Discordian[m]>
The docs and references are also generally very easy to use and read, which I found to be a huge delight coming from C and relying on textbooks for the most part.
<theseb>
Discordian[m]: nice..thanks
cubemonkey has quit [Ping timeout: 240 seconds]
<Discordian[m]>
I thought dtube is interesting but I couldn't figure out how to access it over IPFS.
<swedneck>
dtube is sadly garbage as far as i'm aware
<swedneck>
basically a scam, it says it's decentralized but it's not really
<Discordian[m]>
That's what I thought, I just didn't want to say anything (as I'm a noob)
<theseb>
swedneck: really?...aww that's too bad
<theseb>
swedneck: seems it is censorship resistant..that sounds decentralized but what do i know
<swedneck>
lbry is the only properly distributed content platform like that i'm aware of
<swedneck>
<theseb "jan Swedneck: seems it is censor"> they can claim whatever they want, but they also have to prove it
cubemonkey has joined #ipfs
cubemonkey has joined #ipfs
<Discordian[m]>
They claim to be heavily managed too, meaning they're able to remove content
supercoven has quit [Read error: Connection reset by peer]
<Evanito[m]>
Make it from scratch? That would be a feat
alessandroEtc has quit [Quit: Connection closed]
slby[m] has joined #ipfs
<theseb>
Evanito[m]: what are some complex parts to implementing ipfs?
<Evanito[m]>
It's just a lot of interconnected parts. Not to mention it's built on top of libp2p, which is even more moving parts.
<Evanito[m]>
Reminds me of building an Operating System from scratch: not impossible, but you have to be a little crazy to do it haha
<Evanito[m]>
One advantage you would have though is that IPFS has already explored a lot of experimental paths, so if you just follow in their footsteps it shouldn't take you *too* much R&D to make from scratch
<davidsong[m]>
I think the reading the existing code and understanding the stack is the complex part
<Evanito[m]>
* One advantage you would have though is that IPFS has already explored a lot of experimental paths of development, so if you just follow in their footsteps it shouldn't take you _too_ much R&D to make from scratch
<davidsong[m]>
At least that's my barrier to contributing to pyipfs
<davidsong[m]>
I was hoping that there would be a Python implementation that I could just drop into an already existing pirate media plugin for Kodi, and migrate all the content over to IPFS as users play the content. But it turns out that's not the case, and reading the code to the javascript implementation and python libp2p implementation and reading all those diagrams was a pretty deep rabit hole
Jesin has quit [Quit: Leaving]
<Evanito[m]>
Oh and as we can see from the other ports of IPFS in other languages it can take quite a while even with a team
<Evanito[m]>
Yeah davidsong that's a struggle I've noticed too 😢 I'm not sure if they just want us to interface on top of the local node at this point (like Galacteek gives you the option to) but it's rather difficult to embed an IPFS node into software unless you want to spend a ton of time doing it.
f[x] has joined #ipfs
alessandroEtc has joined #ipfs
Jesin has joined #ipfs
<theseb>
davidsong[m]: lol....pirate media plugin for Kodi
<theseb>
davidsong[m]: is ipfs censorship resistant or can people take down content on it?
<Evanito[m]>
Very censorship resistant theseb The only current method to censor it is to request public gateways to not serve certain CIDs.... but you can defeat this by running your own node
<Evanito[m]>
Don't confuse this with being anonymous, which it is not. It is not a difficult process to see which IP address is holding a certain file/CID, much like BitTorrent
crossbeau has joined #ipfs
<alessandroEtc>
dtube is not actually decetrnalized
<theseb>
Evanito[m]: so that means if someone runs their own node that person's identity/location could be found and he/she could become a target if someone cared
<theseb>
:(
<theseb>
alessandroEtc: if the content is on ipfs then that part is decentralized no?
<alessandroEtc>
yes, but it doesn't appear to be set up that way
<Evanito[m]>
I just opened up a dtube video and it was just a YouTube embed 😅
<theseb>
hmm
<swedneck>
ipfs is censorship resistant, like torrent
<swedneck>
as long as you can reach someone that is seeding the content, you can get it
<Discordian[m]>
Yeah again dtube can and will remove content. It's heavily moderated
kn0rki has quit [Quit: Leaving]
crossbeau has quit [Quit: Connection closed]
zeden has quit [Quit: WeeChat 3.0]
<vaultec81[m]1>
I've heard there is going to be another video platform using ipfs very soon.
<wings[m]>
;) yep
<wings[m]>
I heard that too......
<theseb>
The world needs good censorship resistant communications tools
<theseb>
Best I'm aware of is Tor Hidden Services
<theseb>
i'm not aware of anything that can compete w/ that
<wings[m]>
Try ZeroTier
<wings[m]>
Srsly
<wings[m]>
It doesn't do onion routing yet but it does do E2EE, tunneling and the best routing protocols I've ever seen
korra has joined #ipfs
miceiken has quit [Quit: Connection closed for inactivity]
<swedneck>
oh phew, i thought you said zeronet
Ringtailed_Fox has quit [Read error: Connection reset by peer]
gdrey[m] is now known as gdrey[m]1
Ringtailed_Fox has joined #ipfs
chivay[m] has joined #ipfs
Newami has joined #ipfs
Newami has quit [Remote host closed the connection]