<AphelionZ>
I could use some guidance from here... I can't tell if my reverse proxy is busted or something else.
<AphelionZ>
I'm still getting the Circuit not enabled error when I try to connect to my server's websocket
<AphelionZ>
but the interesting thing is when I call ipfs.swarm.connect from my browser my laptop fan goes NUTS
<AphelionZ>
hahah
Alpha64_ has quit [Ping timeout: 248 seconds]
colatkinson has joined #ipfs
<AphelionZ>
anyway, let me know... I'd love some help with this
Alpha64 has joined #ipfs
Alpha64 has quit [Changing host]
Alpha64 has joined #ipfs
mtstickney[m] has joined #ipfs
shizy has quit [Ping timeout: 246 seconds]
rngkll has joined #ipfs
ps5 has quit [Quit: Leaving.]
ps5 has joined #ipfs
ps5 has left #ipfs [#ipfs]
ps5 has joined #ipfs
ygrek has quit [Ping timeout: 248 seconds]
witten has joined #ipfs
ps5 has left #ipfs [#ipfs]
ps5 has joined #ipfs
l2d has quit [Remote host closed the connection]
l2d has joined #ipfs
ps5 has quit [Ping timeout: 260 seconds]
colatkinson has quit [Ping timeout: 248 seconds]
Mateon3 has joined #ipfs
Mateon1 has quit [Ping timeout: 268 seconds]
Mateon3 is now known as Mateon1
robattila256 has quit [Quit: WeeChat 2.0.1]
Anton_ has quit [Ping timeout: 265 seconds]
colatkinson has joined #ipfs
Anton_ has joined #ipfs
chriscool1 has quit [Quit: Leaving.]
anewuser has quit [Ping timeout: 240 seconds]
jesse22 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
warner` is now known as warner
robattila256 has joined #ipfs
mtodor has joined #ipfs
mtodor_ has joined #ipfs
mtodor has quit [Read error: Connection reset by peer]
mtodor_ has quit [Remote host closed the connection]
mtodor has joined #ipfs
mtodor has quit [Remote host closed the connection]
webdev007 has quit [Quit: Leaving]
colatkinson has quit [Quit: colatkinson]
mtodor has joined #ipfs
mtodor has quit [Remote host closed the connection]
mtodor has joined #ipfs
mtodor has quit [Remote host closed the connection]
mtodor has joined #ipfs
mtodor has quit [Remote host closed the connection]
mtodor has joined #ipfs
mtodor has quit [Remote host closed the connection]
mtodor has joined #ipfs
mtodor has quit [Remote host closed the connection]
mtodor has joined #ipfs
mtodor has quit [Remote host closed the connection]
mtodor has joined #ipfs
mtodor has quit [Remote host closed the connection]
preea[m] has joined #ipfs
mtodor has joined #ipfs
mtodor has quit [Remote host closed the connection]
ONI_Ghost has joined #ipfs
ONI_Ghost has quit [Read error: Connection reset by peer]
ulrichard has joined #ipfs
letmutx has quit [Quit: Connection closed for inactivity]
mtodor has joined #ipfs
mtodor has quit [Remote host closed the connection]
colatkinson has joined #ipfs
Alpha64 has quit [Read error: Connection reset by peer]
rendar has joined #ipfs
Kythyria[m] has quit [Ping timeout: 255 seconds]
mtodor has joined #ipfs
mtodor has quit [Remote host closed the connection]
Kythyria[m] has joined #ipfs
mtodor has joined #ipfs
chriscool1 has joined #ipfs
faenil has quit [Remote host closed the connection]
robattila256 has quit [Ping timeout: 256 seconds]
inetic has joined #ipfs
ylp has joined #ipfs
robattila256 has joined #ipfs
reit has quit [Quit: Leaving]
VeggieVampire has joined #ipfs
mildred has joined #ipfs
xzha has joined #ipfs
Neomex has quit [Remote host closed the connection]
yuhl_ has joined #ipfs
yuhl_ has quit [Read error: Connection reset by peer]
konubinix has quit [Ping timeout: 268 seconds]
konubinix has joined #ipfs
maxzor has joined #ipfs
cxl000 has joined #ipfs
mildred has quit [Quit: mildred]
rcat has joined #ipfs
bomb-on has quit [Quit: zzz]
}ls{ has joined #ipfs
bomb-on has joined #ipfs
MikeFair has quit [Quit: Leaving]
colatkinson has quit [Quit: colatkinson]
yuhl_ has joined #ipfs
aananev has joined #ipfs
yl[m] has joined #ipfs
quadriurate has joined #ipfs
chriscool1 has quit [Ping timeout: 264 seconds]
quadriurate has quit [Read error: Connection reset by peer]
letmutx has joined #ipfs
vmx has joined #ipfs
clemo has joined #ipfs
stavros has joined #ipfs
<stavros>
hello
<stavros>
how can i automatically republish my ipns names?
plexigras has joined #ipfs
Fess has quit [Ping timeout: 264 seconds]
raynold has quit [Quit: Connection closed for inactivity]
<JCaesar>
stavros: Your default key should be automatically taken care of. For the rest, you need a cronjob.
dimitarvp has joined #ipfs
columelliform has joined #ipfs
jkilpatr has joined #ipfs
captain_morgan has quit [Ping timeout: 248 seconds]
dvn has quit [Ping timeout: 276 seconds]
frist has quit [Ping timeout: 276 seconds]
frist has joined #ipfs
pierce has quit [Ping timeout: 255 seconds]
keks[m] has quit [Ping timeout: 255 seconds]
dvn has joined #ipfs
raynold has joined #ipfs
columelliform has quit [Remote host closed the connection]
pierce has joined #ipfs
keks[m] has joined #ipfs
robattila256 has quit [Quit: WeeChat 2.0.1]
<victorbjelkholm>
JCaesar: I think by default IPNS Republish is disabled, if you look at `RepublishPeriod` with `cat $IPFS_PATH/config | jq .Ipns`
<stavros>
victorbjelkholm, ah, thanks
<victorbjelkholm>
stavros: I think you can set that string to a Golang duration, and it'll republish at that interval, but you gotta try it, I might remember wrong
<victorbjelkholm>
someone from the go-ipfs will know more
<stavros>
victorbjelkholm, hmm "RepublishPeriod A time duration specifying how frequently to republish ipns records to ensure they stay fresh on the network. If unset, we default to 4 hours."
<victorbjelkholm>
hm indeed, "ipns records" (in plural) sounds like it'll republish all ipns records, but as JCaesar says, I think it's just the default key/ipns record, not all of them. But I'm in unfamiliar waters now, so unsure
<stavros>
i'd have to change my cronjob every time i repoint the record
yuhl_ has quit [Ping timeout: 276 seconds]
<victorbjelkholm>
stavros: how about something like this? HASH=QmVDE9sVonk5dqn4ox7CqH8xqhkD8ZEvbiRXcdqRomTJ9b ipfs name resolve $HASH | ipfs name publish --key=my-website
<victorbjelkholm>
replace `my-website` with the name of your key
<victorbjelkholm>
HASH is the IPNS record entry's hash
infinisil has quit [Quit: ZNC 1.6.5 - http://znc.in]
infinisil has joined #ipfs
inetic has quit [Remote host closed the connection]
<stavros>
victorbjelkholm, hmm, that's taking a while to resolve
<victorbjelkholm>
stavros: yeah, resolve/publish is slow right now, vyzo (I'm 90% sure) is working on speeding up IPNS currently
<victorbjelkholm>
but that command will work for whatever hash you have published, and you don't need to change the command when the hash itself changes
<stavros>
victorbjelkholm, yep, just tried it and it seems to have worked, thanks!
saki has joined #ipfs
<victorbjelkholm>
:)
gmoro_ has joined #ipfs
lord| has quit [Ping timeout: 248 seconds]
gmoro has quit [Ping timeout: 256 seconds]
stavros has quit [Quit: Leaving]
inetic has joined #ipfs
pmilot[m] has joined #ipfs
transmission has joined #ipfs
robattila256 has joined #ipfs
f33d has joined #ipfs
<AphelionZ>
might anybody be around to help me with the issues I was having last night?
<AphelionZ>
if somebody else wants to try that, that'd be awesome
<AphelionZ>
it looks like the issue may be with my nginx config
<victorbjelkholm>
yeah, I don't see anything immediately wrong, but maybe skip the `relay` part of the experimental config unless you're actually using it?
<AphelionZ>
ok
<AphelionZ>
i fixed a server config issue and now I'm getting a 400 error... progress!
<AphelionZ>
my next goal is to have some sort of connection between a node.js ipfs script <---> my go-ipfs server <----> n number of browser nodes
<AphelionZ>
making a "persistent peer"
inetic has quit [Ping timeout: 255 seconds]
inetic has joined #ipfs
f33d has quit [Remote host closed the connection]
f33d has joined #ipfs
espes__ has quit [Ping timeout: 256 seconds]
f33d has quit [Ping timeout: 246 seconds]
VeggieVampire has quit [Ping timeout: 260 seconds]
zautomata has joined #ipfs
zautomata has quit [Changing host]
zautomata has joined #ipfs
zautomata has quit [Client Quit]
zautomata has joined #ipfs
captain_morgan has joined #ipfs
espes__ has joined #ipfs
Alpha64 has joined #ipfs
ylp has left #ipfs [#ipfs]
sz0 has joined #ipfs
fredthomsen has quit [Quit: Leaving.]
ulrichard has quit [Ping timeout: 240 seconds]
fredthomsen has joined #ipfs
fredthomsen has quit [Read error: Connection reset by peer]
noobineer has joined #ipfs
noobineer has quit [Max SendQ exceeded]
noffle has joined #ipfs
Ellenor is now known as Reinhilde
transmission has quit [Ping timeout: 260 seconds]
yuhl_ has quit [Quit: yuhl_]
xzha has quit [Ping timeout: 240 seconds]
bomb-on has quit [Quit: SO LONG, SUCKERS!]
Neomex has joined #ipfs
bomb-on has joined #ipfs
Xiti has quit [Quit: Xiti]
Xiti has joined #ipfs
jkilpatr_ has joined #ipfs
jkilpatr has quit [Ping timeout: 256 seconds]
Reinhilde is now known as Ellenor
jkilpatr_ has quit [Ping timeout: 265 seconds]
bomb-on has quit [Quit: zzz]
Ellenor is now known as Reinhilde
mtodor has quit [Remote host closed the connection]
f33d has joined #ipfs
Ecran has joined #ipfs
f33d has quit [Remote host closed the connection]
f33d has joined #ipfs
f33d has quit [Ping timeout: 256 seconds]
inetic has quit [Ping timeout: 256 seconds]
dconroy has joined #ipfs
<AphelionZ>
if I do an ipfs.files.get in the browser, and I'm manually connected to a go node via websockets... what might be preventing it from getting the file I requested?
<AphelionZ>
It just times out
<AphelionZ>
does it get it via the websocket? or does it then connect to the gateway?
<AphelionZ>
this is the hash I'm trying to get: QmemJwwgeGckPXbuk8ckzHvKxbueJQZ95QLy1J8gKnMdiB
<AphelionZ>
I just can't seem to get my browser node to find it
<AphelionZ>
I think it has to do with my nginx proxy, for better or worse
Mitko_ has joined #ipfs
jkilpatr has joined #ipfs
<victorbjelkholm>
AphelionZ: why don't you try setting up everything without the nginx proxy first? Expose the swarm endpoints directly, then once you get it working, add the proxy over it
<AphelionZ>
victorbjelkholm: because of SSL :/
<AphelionZ>
if I dont use SSL in the browser, it won't let me use webcrypto
<victorbjelkholm>
there is a flag when starting the browser to control that
<victorbjelkholm>
--disable-web-security in chrome I think, useful for debugging stuff
<AphelionZ>
gotcha
<AphelionZ>
I just want to know if I need any orther ports open
rendar has quit []
sz0 has quit [Quit: Connection closed for inactivity]
<victorbjelkholm>
5001 should be enough
<AphelionZ>
ah! 5001
<victorbjelkholm>
eh sorry no
raynold has joined #ipfs
<victorbjelkholm>
that's the api. 4001 is the default swarm and then ws endpoints are usually set to 9999 or something like that
<AphelionZ>
I have 4003 (nginx) -> 4002 (local) for websockets, that works great
<victorbjelkholm>
but if you can receive files from one side, it should work from the other side
<AphelionZ>
and then I have 443 (nginx) -> 8080 (local) for the gateway
<AphelionZ>
yeah its weird how it's not working in both directions
plexigras2 has joined #ipfs
plexigras has quit [Ping timeout: 260 seconds]
muravey_ has joined #ipfs
bomb-on has joined #ipfs
muravey_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<AphelionZ>
crap... it appears that getting files does NOT work from browser --> go node, even though I can dial and connect them as peers
muravey has joined #ipfs
muravey has quit [Client Quit]
guideline has quit [Read error: Connection reset by peer]
<AphelionZ>
looks like while my go node registers as a peer inside my browser's ipfs.swarm.peers call, my browser does not appear as a peer in my `ipfs swarm peers` cli call
<AphelionZ>
oooh hang on
<AphelionZ>
it works :D it just looks like I need to re-dial every now and again from the browser maybe
f33d has quit [Remote host closed the connection]
<AphelionZ>
gonna try adding it to the swarm config
<AphelionZ>
and i'll stop flooding the channel with my play by play now :) thanks for listening
f33d has joined #ipfs
f33d has quit [Ping timeout: 248 seconds]
jkilpatr has quit [Ping timeout: 260 seconds]
<tsglove>
is there an ipfs torrent website?
anthrax314[m] has joined #ipfs
pelegreno has quit [Remote host closed the connection]
pelegreno has joined #ipfs
f33d has joined #ipfs
guideline has joined #ipfs
erde74 has joined #ipfs
<AphelionZ>
tsglove: not that I know of. You should start one :)
f33d has quit [Remote host closed the connection]
f33d has joined #ipfs
warner has quit [Ping timeout: 265 seconds]
warner has joined #ipfs
f33d has quit [Ping timeout: 240 seconds]
muravey has joined #ipfs
colatkinson has joined #ipfs
muravey has quit [Client Quit]
vmx has quit [Ping timeout: 240 seconds]
erde74 has quit [Quit: Leaving]
dconroy has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
newhouse has joined #ipfs
cxl000 has quit [Ping timeout: 255 seconds]
<r0kk3rz>
putting torrent files on ipfs? sounds a bit asinine :)
Matrixiumn has quit [Ping timeout: 240 seconds]
astrofog has joined #ipfs
clemo has joined #ipfs
warner has quit [Quit: ERC (IRC client for Emacs 25.1.1)]
MikeFair has joined #ipfs
cxl000 has joined #ipfs
<victorbjelkholm>
speaking about torrents, I made a util for converting magnet stuff into IPFS, works with torrent files as well, if you change the code slightly, https://github.com/VictorBjelkholm/magnet-to-ipfs
Ecran has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<fR_>
Hello, I have a question about interoperability between the js and go implementations. If I add a file using the js in-browser api and attempt to retrieve it using the go daemon/command line (ipfs get hash), the command hangs forever. However if I request the hash from the public ipfs.io web gateway (https://ipfs.io/ipfs/hash), it not only works instantly but also "fixes" the hanging command-line get command which also
<fR_>
successfully returns the file. Why is this?
<JCaesar>
I feel like I've seen this behaviour… with two go-ipfs and ipfs.io… (nevermind me)
<EnricoFasoli[m]>
Probably because the js implementation immediately connects to the node(s) powering ipfs.io because they are in the bootstrap list, but does not connect to your local go-ipfs because by default it does not accept transports that can be dialed from the browser (webrtc and websockets) and also it's not in the bootstrap list
<EnricoFasoli[m]>
So when you fetch the file from ipfs.io, your local go-ipfs node which is already connected to the ipfs.io node(s) immediately finds that one of his peers has the data and retrieves it
otremblay has joined #ipfs
<EnricoFasoli[m]>
What's more mysterious is the problems that AphelionZ was having since he was not seeing instant transfers between two nodes that were directly connected
Mitko_ has quit [Quit: Leaving]
<EnricoFasoli[m]>
Anyway if my understanding is correct once circuit relay is ready maybe this problem will go away
<AphelionZ>
I solved it
<otremblay>
Hi, I had a question related to file availability, privacy, and stuff
<otremblay>
Say that I want to use IPFS as a means to make my music library readily available over the network for my own use, how likely is it that someone would stumble upon it by accident?
<EnricoFasoli[m]>
very likely
<victorbjelkholm>
otremblay: extremely unlikely, unless they are listening to DHT requests. But if you run a private network with just your node, you should be safe
<infinisil>
haha
<Icefoz>
hah.
<fR_>
EnricoFasoli[m] so currently two nodes must be able to communicate directly if the content is only available on one of those two nodes, the "ipfs.io" node can't relay the content? but this will be fixed by the circuit relay feature?
<EnricoFasoli[m]>
hahaha I love how our responses were so different
<victorbjelkholm>
EnricoFasoli[m]: haha, yeah! I guess it depends on how you see it
<EnricoFasoli[m]>
fR_: yes I think so
<Michcioperz[m]>
oh, this is what I needed a few months ago
<Michcioperz[m]>
thanks
<EnricoFasoli[m]>
My first thought were the people saying that there are crawlers that cache stuff that appears in the dht
<fR_>
gotcha, thank you! how can I enable websockets/webrtc in my go node?
<victorbjelkholm>
if you just start ipfs and add stuff, it's likely someone is scraping the dht and ends up with your hashes. But with private network or running ipfs in offline, it's very unlikely someone will somehow guess the hash
<Icefoz>
otremblay: It's basically impossible to start with no IPFS hash or data and conjure up an IPFS hash that points to something real. But the IPFS protocol does a lot of chattering about what hashes each node has available and isn't really intended to hide that, unless you use a private network.
<otremblay>
I'm mildly confused. :P I took a look at that, I was wondering whether I should go ahead and host an ipfs daemon somewhere just so that I'd have a private swarm.
<infinisil>
hmm, a private ipfs network connected through openvpn would be a nice way to have a shared library between computers
<otremblay>
I guess it probably makes sense to have the private swarm set up
<victorbjelkholm>
otremblay: yeah, you need to have a daemon running *somewhere*
<Icefoz>
otremblay: If you have a private network configured then nodes in that network will only chatter to each other.
<victorbjelkholm>
then other clients can use the api or http gateway. But at least one daemon
<otremblay>
Piggy-backing on the public dht seemed like a nice idea.
<EnricoFasoli[m]>
honestly I'm curious about whether adding some copyrighted stuff to IPFS without sharing the hash is considered distribution of copyrighted content
jkilpatr has joined #ipfs
<Icefoz>
EnricoFasoli[m]: Probably depends on your lawyer.
<tsglove>
AphelionZ, sounds quite tempting!
<fR_>
EnricoFasoli[m]: I'm also seeing that content added by a browser node can't be retrieved by another browser node until separately requesting it from ipfs.io. shouldn't the two browser nodes be able to find each other and connect, since they both use the same transport?
<otremblay>
I come from trying to do the exact same thing with dat (datproject.org) and failing miserably
<EnricoFasoli[m]>
fR_: yes they should but it might take some time. Also if both are behing unpunchable nat or strict firewalls they will just never connect directly
<fR_>
I see.
<EnricoFasoli[m]>
there are thousands of ipfs nodes. I work a lot with ipfs but ironically I can't run my own node since I have a 7Mbit download bandwidth with about 500 Kbit/s of upload. If I run an IPFS node I can't do anything else
<Icefoz>
otremblay: Odd, I'd imagine dat would be ideal for that. Though I use syncthing for my music library. ;-)
<EnricoFasoli[m]>
I just open it occasionally but mostly use remote gateways
<r0kk3rz>
otremblay: imo for copyright infringement, not having public DHTs seems like a feature
<otremblay>
r0kk3rz: Definitely.
<otremblay>
Icefoz: Library too big, somehow also fails when accessing it from the outside (which ipfs does not)
<Icefoz>
otremblay: Aww, that sucks.
<fR_>
I am able to connect to the other browser using a non-ipfs webrtc demo app. So I'm still a bit confused why browser<->browser ipfs isn't working.
<otremblay>
Icefoz: does syncthing require you to sync all the things, or you can sync SOME things on demand?
<Icefoz>
otremblay: It syncs all the things in a folder. You can specify whatever folder(s) you want.
<otremblay>
Icefoz: I have around 30 gigs of CDs I made perfectly legal copies of over time, and my phone has... much less space. XD
<otremblay>
While I'd enjoy having two copies of the library (because hard drives sometimes die), I'd rather have a solution that can do stuff on demand (like IPFS, for example)
<Icefoz>
Yeah, I know the feeling.
plexigras2 is now known as plexigras
<r0kk3rz>
yeah i guess most people delegate that problem to spotify these days
Encrypt has joined #ipfs
<AphelionZ>
Basically I have ONE bootstrap node in my app now, which is MY ipfs server lol
<AphelionZ>
and so long as the ipfs swarm peers command reports both nodes, from both sides, I can share files
warner has joined #ipfs
espadrine has joined #ipfs
Jesin has joined #ipfs
leebyron has quit [Remote host closed the connection]
f33d has joined #ipfs
f33d has quit [Remote host closed the connection]
<MikeFair>
AphelionZ, hey you gotta sec?
<AphelionZ>
ya
<MikeFair>
AphelionZ, can you open /orbitdb/QmS2wfjYZR1mSsiQayzoXK6SQyCGDkMfdGKNAEk9tooWFr/users
<AphelionZ>
I don't think I can, currently
muvlon has joined #ipfs
<AphelionZ>
unless there's like an orbit viewer or something
<AphelionZ>
well, hang on
<MikeFair>
I'm working with someone else and trying to figure out why I can't see the DB after he creates it
<AphelionZ>
MikeFair: I can't right now because of the question I need to ask lol
<AphelionZ>
which is... with orbit is it possible to connect to an existing ipfs node
<AphelionZ>
and use that for the underlying ipfs
<AphelionZ>
instead of having to create a new node every time
<James_Epp>
Does anyone know of a way to manually fix the order of the autocomplete contact list in the To: field in Office 2016 Outlook? My internal email is james@xxxxx and I have another contact, jamesr@xxxxx and when I try to send myself a quick note in my own mailbox, it prefers (by the order) to send it to that user, and by my own use and haste of CTRL+Enter to send the email, it's too late by the time I notice my error.
<AphelionZ>
basically I have a go node running now, and browsers that will happily interop with it
<MikeFair>
AphelionZ, It should be, it's like connecting to the local daemon; just don't use a 127.0.0.1 address right?
<AphelionZ>
but where and how do I do that?
<AphelionZ>
in the js-ipfs config
<AphelionZ>
James_Epp: I think you need to use ipfs dag put and ipfs dag get
<James_Epp>
AphelionZ: Ha -- very funny.
<AphelionZ>
;)
<James_Epp>
Can't believe I just entered the wrong channel.
<AphelionZ>
so like... how do I tell either js-ipfs or orbitdb to connect to my mothership go node instead of trying to create its own ipfs repo
<AphelionZ>
I'm fine with it wanting to use the filesystem, but theoretically I'm gonna have thousands of these little robot peers and I can't really spare the ports
<AphelionZ>
alternatively, and I'm playing with this now - just stuff them all in docker containers
* MikeFair
hangs head in shame as comprehension dawns upon him.
<AphelionZ>
lol
<AphelionZ>
yeah it needs to be a proper js-ipfs object, not a js-ipfs-api object
<AphelionZ>
i think I need to containerize each of these things.... ugh
<EnricoFasoli[m]>
There is a problem with a library it uses which calls libp2p directly and that is not possible with js-ipfs-api
<MikeFair>
I think there was an orbit issue about bringing back API support
<AphelionZ>
EnricoFasoli[m]: do you grok the issue I'm dealing with then?
<EnricoFasoli[m]>
If you want to use the js-ipfs object but leverage an existing go-ipfs node instead of js-ipfs being its own node then you want js-ipfs-api
leebyron has joined #ipfs
<AphelionZ>
but then I can't use orbit :/
<MikeFair>
EnricoFasoli[m], Which doesn't work with OrbitDB unfortunately
<AphelionZ>
can I bypass js-ipfs and just use orbit directly with the go node?
<EnricoFasoli[m]>
Yep there is a official one on the hub at ihub.docker.com/ipfs/go-ipfs
<Icefoz>
Heyyyyy, there is.
<MikeFair>
This seems to be the heart of it:
<MikeFair>
Implement direct-connection mechanism that we get from ipfs-pubsub-room in ipfs-api compatible way (More details: ipfs-shipyard/ipfs-pubsub-room#28, tl;dr we use libp2p primitives in pubsub-room that are not exposed by ipfs-api). To make this work with ipfs-api, it means essentially writing a new component and replace the direct-connection part of ipfs-pubsub-room. This is trickier as it touches bunch of layers and modules and
<MikeFair>
comes with trade-offs and design considerations explained in the issue.
<MikeFair>
AphelionZ, How does docker solve the issue?
<EnricoFasoli[m]>
yep, it's from ipfs-pubsub-room which is a nice abstraction over pubsub, however it calls libp2p which you can't do over the api which is why it does not work without a full js node
<MikeFair>
Does this limitation go away when js-ipfs supports routing/DHT et al.
<MikeFair>
oh nm
<MikeFair>
it's that there's no end points for exposed in the APi
<MikeFair>
I wonder if there's a way to make new end points in the full node to abstract it for the API
<MikeFair>
The idea being the API is the "last hop" to the edge, and making its "supplier node" do a little more havy lifting on its behalf might not be the end of the world
<AphelionZ>
MikeFair: I think I can have each container run its own IPFS node, localized to the ports of the container
<MikeFair>
Right, but what does that get you for the remote browsers??
<AphelionZ>
well I can then peer those with my "public" go node
<MikeFair>
Or creators of the OrbitDBs
<AphelionZ>
and then they can all swarm happily
<AphelionZ>
again, this is all theoretical
<AphelionZ>
i havent tried it yet
<AphelionZ>
what it gets the creators of the OrbitDB is a more robust network for replication, swarming, and pubsub
<MikeFair>
I think the issue have is that those Docker images would need to create the OrbitDB using the JS CLI
<MikeFair>
I think the issue have is that those Docker images would need to create the OrbitDB using the JS Node server
<AphelionZ>
yes, that's correct
<MikeFair>
Otherwise the Orbit address is owned by the browser
<MikeFair>
which doesn't seem to get shared out that easily
<AphelionZ>
but I've proven that js-ipfs can interop with go-ipfs via the browser, so long as I directly connect the nodes instead of relying on DHT
* MikeFair
still hasn't been able to create an Orbit database that a remote browser can see.
<MikeFair>
Yes, we've seen that too
<AphelionZ>
so I just do that, but locally, between the guest containers and the host go-node
<MikeFair>
So you're thinking that if you directly connect to docker, then the new dbs will be shareable with wider browser Orbit world?
<AphelionZ>
that should "probably" "work" FSVO probably and work
<AphelionZ>
that's what I'm thinking, yes, because they'd allllllll be swarmed together
<AphelionZ>
then its just like.. add more RAM and storage all the live long day ;)
cxl000 has quit [Ping timeout: 248 seconds]
<MikeFair>
I'm wondering how that's different than the core JS IPFS swarm bootstrab nodes though
<MikeFair>
I'm wondering how that's different than the core JS IPFS swarm bootstrap nodes though
<AphelionZ>
mm, that's a good question and probably a good point
<AphelionZ>
... I'm gonna try it anyway
* MikeFair
nods.
<MikeFair>
Ping me if I can help
<AphelionZ>
ty
<MikeFair>
afk bbiab
colatkinson has quit [Quit: colatkinson]
colatkinson has joined #ipfs
simonDos[m] has joined #ipfs
muravey has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
infinisil has quit [Quit: ZNC 1.6.5 - http://znc.in]
noresult has joined #ipfs
infinisil has joined #ipfs
muravey has joined #ipfs
Jesin has quit [Quit: Leaving]
muravey has quit [Client Quit]
tarrence has joined #ipfs
<tarrence>
Hi, is it possible to publish to ipns using a remote node?
infinisil has quit [Quit: ZNC 1.6.5 - http://znc.in]
<tarrence>
I'd like to generate a private key adhoc and publish to ipns without the user having to have ipfs installed locally
infinisil has joined #ipfs
letmutx has quit [Quit: Connection closed for inactivity]
muravey has joined #ipfs
dconroy has joined #ipfs
<tarrence>
For example, instead of `curl 'http://localhost:5001/api/v0/name/publish?arg=/ipfs/QmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR&key=test'` where the node expects a key pair "test" locally, is it possible to sign a transaction before sending it to a node, so they key isn't exposed to the node
<MikeFair>
tarrence, yes, use a custom key
<AphelionZ>
MikeFair: it looks like you're right :/
<AphelionZ>
I can get my docker node.js js-ipfs node, my go-node, and my browser nodes pseudo-swarming via the go-node
<AphelionZ>
but I can't connect orbit across all of them
<MikeFair>
tarrence, oh that's a bit different; what you want is the js-ipfs-api
<MikeFair>
actually, not even that
Encrypt has quit [Quit: Quit]
<MikeFair>
tarrence, There's lot of "tricks" you can do to make that work; so in terms of "possible" yes, but ootb (out of the box); I'm not sure
<tarrence>
Could you describe a trick?
<tarrence>
As far as I can see, there is no way to delegate publishing to ipns to a remote node without exposing the private key to them atm
robattila256 has joined #ipfs
<MikeFair>
tarrence, A simple strategy would be to have your local node publish something as a command (signed/encrypted by the lcoal node); then post that CID to the remote node for "processing"
<MikeFair>
The remote node validates the message is from an authorized "remote publisher" then republishes as itself
<MikeFair>
or using its own custom key
<MikeFair>
tarrence, You could even use ipns to do it
<MikeFair>
tarrence, So all the "remote publishers" use their own ipns entry which is registered with the remote node in advance
<MikeFair>
(that's the "authentication" part)
<MikeFair>
the local node then using its own unique key to upload the data and update its own unique IPNS entry
<MikeFair>
it then fires a message to the "remote node" saying "Hey, I changed my stuff; republish that"
<MikeFair>
You only distribute the "central" IPNS address
<MikeFair>
unless what you're asking is can you have multiple private keys update the same IPNS address; in which case the answer no, not currently
<tarrence>
Hmm interesting, ultimately I'd like to avoid having to run a local node but I guess that is not possible right now
<MikeFair>
tarrence, js-ipfs-api
<MikeFair>
tarrence, It's a "lightweight" API that only connects to a remote node
<tarrence>
It seems the system you described wouldn't be possible using the api client
<tarrence>
Since it references private keys by name
<MikeFair>
tarrence, those names are relative to the node being connected to
<tarrence>
And would still require "remote publishers" to have a local node in order to have their own ipns address space
<MikeFair>
Yes, but that's only one-way to authenticate tehy are authorized to submit the request
<tarrence>
If I am understanding correctly
Hitechcg has quit [Remote host closed the connection]
<MikeFair>
I understood you primarily wanting to protect the real private key for the IPNS entry
<tarrence>
Gotcha. Ideally I would be able to sign a publish request locally as authentication and have a remote node publish it to the corresponding ipns address
<MikeFair>
tarrence, You can do that a bunch of ways; primarily think of the request as its own file you publish on IPFS first; that gives you a CID for the request; you then need to get that CID to the remote publisher
<AphelionZ>
OR
<AphelionZ>
I could create a node.js app that runs ipfs inside of it
<AphelionZ>
and build the peers off of that
<MikeFair>
pubsub?
<AphelionZ>
that way it's all sort of in the same... thing
<MikeFair>
AphelionZ, Hmmm, what happens if you get the Docker nodes to attempt directly connecting to all the browser
<AphelionZ>
I dont think they have that visibility
<MikeFair>
AphelionZ, I was able to get my Go instance to listen on WebSockets, but couldn't get a remote browser talking to it; I suspected firewall
vmx has joined #ipfs
<AphelionZ>
see I got past that
<AphelionZ>
I was able to send and receive files between a browser and a go node
<tarrence>
What I would like to do is share a private key amongst contributors so multiple people can update the content at an ipns address without requiring them to install ipfs locally and without requiring them to maintain a local keystore
<tarrence>
How I would like to do this is to have the initial private key creator encrypt the private key using contributor public keys and store that in ipfs itself
<tarrence>
And then users can read the encrypted private key from ipfs, decrypt the key using their private key, and publish to ipns
<MikeFair>
tarrence, You don't want/need to do that
<MikeFair>
If they content publishers aren't running ipfs, it's pointless to give them that private key
<MikeFair>
that private key only gives you authority to update the ipns entry itself (to point it to a new place)
<tarrence>
Thats what I would like to enable them to do
<MikeFair>
You need an ipfs node of some kind to execute that task
<MikeFair>
No its not
Hitechcg has joined #ipfs
<MikeFair>
you want that effect
<MikeFair>
but if your content publishers aren't running ipfs, they aren't updating the ipns entry, therefore they don't need that private key
<tarrence>
So in that case I guess they will need to run ipfs
<MikeFair>
that private key protects the ipns entry, nothing more
<MikeFair>
they need to be able to instruct an ipfs node to do that for them
<MikeFair>
and they only have to authenticate/sign that the content is from them to that remote ipfs node so it can distinguish the difference between your authorized users and me
<MikeFair>
You can have a single "content publishers key" that you distribute, which is different than the ipns entry key
<MikeFair>
I'd give each user their own, but whatever
<tarrence>
Sure but in that case the remote node controls the ipns entry key and as such it requires trust
<MikeFair>
whatever updates the ipns entry is trusted
<MikeFair>
You can somewhat skip ipns and use DNS directly if you'd prefer that....
<AphelionZ>
MikeFair: running ipfs and orbitdb inside of a node.js app, and connecting the browser to that, seems to work
<tarrence>
Ok I see, thanks for the help MikeFair
<MikeFair>
AphelionZ, "that" being the ipfs instance on docker, or the orbitd created ipfs instance?
<AphelionZ>
im not even using docker, just running this script:
<MikeFair>
tarrence, Does what I said help you at all? it sounds like a nice use case for ipfs --- by the way, there's a few of us working on "multiparty" ipns updates; what I wanted/am working on is a content repository / directory where different people controlled different parts of the tree
sim590 has joined #ipfs
<MikeFair>
AphelionZ, But that looks like you just connected your browser to a freshly created ipfs instance by orbitdb? or am I missing something?
lord| has joined #ipfs
<AphelionZ>
the replication magic happens via the database address
<tarrence>
MikeFair, that is actually exactly what I would like. A mutable address where multiple parties can modify the content without having to delegate to a trusted party
<tarrence>
Is there anywhere I can track progress on yours + the multiparty ipns updates work?
<MikeFair>
AphelionZ, There's a logical inconsitency there ;)
clemo has quit [Ping timeout: 264 seconds]
<AphelionZ>
uh oh
colatkinson has quit [Ping timeout: 256 seconds]
<MikeFair>
s/AphelionZ/tarrence
<MikeFair>
sorry wrong person
<AphelionZ>
oh
vmx has quit [Quit: Leaving]
<MikeFair>
tarrence, People are going to have trust something(s)
<MikeFair>
tarrence, If you want a "common tree" with multiple update points, you can do that
<MikeFair>
tarrence, but whatever controls the "trunk" is trusted
<MikeFair>
tarrence, the thing that can update the root of that tree controls the rest
<MikeFair>
tarrence, what's your scenario? People just sharing content with each other?
<MikeFair>
tarrence, Or trying to do something like publish content for a website?
<tarrence>
MikeFair, I'm experimenting with a collaborative git repo stored on ipfs. I'd like the root to be a mutable address so it remains static
<tarrence>
And allow collabs to update without coordinating with other collaborators
<MikeFair>
tarrence, You have two options at the moment; you can "roll your own" mutability, or ipns
<tarrence>
(Other than the initial authorization)
<MikeFair>
tarrence, you might also be interesting in tracking the git integration via ipld
<tarrence>
I've taken a look at that
<MikeFair>
(basically it's using ipfs as a git repo --- currently limited to content of 2MB)
<MikeFair>
tarrence, So how does this correlate to your initial request of asking a remote node to publish for you?
<tarrence>
My current scheme is to have the repo creator generate a private key that controls an ipns namespace, each collab has their own private/public keypair, authorization is done by encrypting the ipns private key using the collaborators public key and storing it at the mutable address
<MikeFair>
(what was the picture in your head of how these remote people didn't have to trust the thing they were submitting to?)
<tarrence>
It correlates since I would like a git-remote-helper implementation that does not assume a local install of ipfs
<MikeFair>
tarrence, but what's to stop my from installing your helper and publishing to your git repo then?
<tarrence>
Since you don't have access to the private key that controls the ipns address
<tarrence>
Since I haven't provided a version of it encrypted using your public key
<MikeFair>
but the moment any one of those remote places gives me the key, your all over and done with
<tarrence>
Sure so authorized collabs are trusted
<MikeFair>
each of those parties can see the unencrypted key
<MikeFair>
that's a lot of trust
<MikeFair>
and no way to fix it
<tarrence>
Yeah that is true
<MikeFair>
when once it's been broken
<tarrence>
It's not ideal I agree, but working within the constraints
<tarrence>
It's the same effectively as an admin in github being compromised
<tarrence>
And as long as you have another level of indirection, you can change the underlying ipns private key
<MikeFair>
Here's what I'd just, a central bot git that hosts the "real ipns address"
<MikeFair>
s/just/suggest
<MikeFair>
then everyone hosts their own local git
<MikeFair>
the central bot pulls from those repos
<MikeFair>
and publishes
<MikeFair>
unless that completely violates the whole point
<MikeFair>
Another mechanism you can use is DNS
<tarrence>
I'd prefer no central bot. I have some ideas of remediating the compromised private key example
<MikeFair>
You have to move ipns addresses
<tarrence>
Yeah exactly
<MikeFair>
which you can do with DNS for example
<tarrence>
True but I would rather not depend on DNS either
<MikeFair>
well once you move ipns addresses anyone who was pulling from that repo needs to update, and that's a lot of assumptions
<MikeFair>
One technique I've been playing with is derived keys
<MikeFair>
so they're never stored
<AphelionZ>
wow this is weird
infinisil has quit [Quit: ZNC 1.6.5 - http://znc.in]
<MikeFair>
you use the 256 bit HASH of a string as the seed to generate the random numbers for the keypair
<AphelionZ>
my node.js ipfs is now connecting to a peer ID I _know_ doesn't exist
<MikeFair>
AphelionZ, doesn't exist anywhere, or just one you didn't create?
<AphelionZ>
one that I created and then nuked by deleting the repo
<AphelionZ>
its not even running???
<AphelionZ>
and the repo doesnt exist anymore either
infinisil has joined #ipfs
<MikeFair>
AphelionZ, is it actually "connected" or attempting to connect; that peer could exist in some peer lists of "things I remember seeing"
<AphelionZ>
maybe
<AphelionZ>
its under ipfs.swarm.peers
<tarrence>
MikeFair, interesting. I'm not sure I follow on how that resolves the issues we've discussed
newhouse has quit [Read error: Connection reset by peer]
<MikeFair>
tarrence, Well it doesn't exactly, just a way to share a key by deriving it
<MikeFair>
tarrence, so that it's never actually stored anywhere
<MikeFair>
(sahre a private key)
<AphelionZ>
ok there's my peer...
<MikeFair>
You still have to protect the secret same as before
<MikeFair>
tarrence, one thing I'm still wondering how to sort out is determining ownership of a namespace by something other than "first one there wins"
<Icefoz>
That's a Hard problem.
<MikeFair>
At best I have "consensus"
<Icefoz>
Because it's a human problem, not a computer problem.
<Icefoz>
Who *should* own a namespace?
<MikeFair>
yep
<MikeFair>
or "I need that computer to no longer own that namespace"
<MikeFair>
say it was destroyed in a fire and the keys gone and we need to take it back
<MikeFair>
So far, I'm having trouble doing better than DNS
<Icefoz>
There's not many really really good types of human system for solving that kind of problem.
<MikeFair>
And/Or some kind of consensus driven system
<Icefoz>
As far as I know your choices are "dictatorship", "first-come-first-serve", "capitalism", "benign bureaucracy" and "democracy".
dimitarvp` has joined #ipfs
<MikeFair>
hmm, how would capitalism differ from "first-come-first-served"
<MikeFair>
this is about removing control from an existing controller
<MikeFair>
without their consent
<Icefoz>
You can be outbid, like namecoin.
<MikeFair>
Wow --- ok, I get it -- but the concept somewhat revolts and seems extremely circular
<MikeFair>
:)
<MikeFair>
but yeah, that works
<AphelionZ>
MikeFair: DID IT!
<AphelionZ>
I got my node.js orbitdb to get a replication from the browser
<tarrence>
MikeFair, in that case, if you own the source of entropy for derived keys you effectively own the private key no?
<MikeFair>
tarrence, yes
<MikeFair>
tarrence, and by extension, can share something that's not exactly a key; or use a "hopping key" like a TOTP token
dimitarvp has quit [Ping timeout: 248 seconds]
<AphelionZ>
I still have a ghost peer, and I can't get to my public gateway anymore.... but it works
<Icefoz>
MikeFair: If you can come up with an automatic and bulletproof way to fairly distribute limited resources, I'm sure humanity will be grateful. ;-)