<TrUsT_n1>
Trying to figure out how the File Versioning with IPFS works. Don't you just make the changes and re-pin the file. How do you look at the versions?
zcstarr has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
leolrrj has quit [Remote host closed the connection]
leolrrj has joined #ipfs
leolrrj has quit [Read error: Connection reset by peer]
leolrrj has joined #ipfs
chowie has joined #ipfs
chowie has quit [Read error: Connection reset by peer]
chowie has joined #ipfs
chowie is now known as Guest3545
kert[m] has joined #ipfs
daMaestro has joined #ipfs
mazeto has quit [Ping timeout: 276 seconds]
Guest3545 has quit [Quit: Leaving]
<epergny>
TrUsT_n1: you cannot "re-pin" a file that has new version. That'd be a new pin.
<epergny>
TrUsT_n1: and the old file would still be pinned (if it was pinned to start with).
<epergny>
TrUsT_n1: as I understand it if you add file named "a" which has multihash, say, "GmW3d8F97...", the notion of "a" doesn't exist. Only "GmW3d8F97..." does.
<epergny>
TrUsT_n1: so if you later add a new version of a, which now hashes to another hash, say "Qm0f83fl...", then you have both "QmW3d8F97..." and "Qm0f83fl..."
<epergny>
TrUsT_n1: when you add a single file I think you can force it to be wrapped by a directory, so that the name of the file is available. But then the directory has no name, only a hash.
screensaver has quit [Remote host closed the connection]
screensaver has joined #ipfs
<TrUsT_n1>
epergny: Wouldn't the directory hash change if you edited the file?
Fessus_ is now known as Fessus
flyingkiwi has quit [Ping timeout: 260 seconds]
ONI_Ghost has joined #ipfs
<epergny>
TrUsT_n1: ofc it changes...
flyingkiwi has joined #ipfs
<epergny>
TrUsT_n1: so now you have the old directory, with say hash "Qm4v0wv98...", which has file named "a" version x with hash "Qm0fv98q7w0..." and then you also have the new directory, with say hash "Qm29fv0v98....", which has also a file named "a", version x+1 (but that IPFS knows nothing about), with hash "Qmav0987ewj..."
<epergny>
TrUsT_n1: from what I understand IPFS, by being a content-based addressing filesystem, provides you de-duplication and integrity checks for free but doesn't provide versioning. It's not a VCS.
<epergny>
TrUsT_n1: although unless you specifically unpin your old versions, they'll all be there.
<epergny>
TrUsT_n1: it's all new to me... I did lots of test locally with throwaway repos: adding files, checking their hashes, adding directories, modifying one file, etc.
<ToxicFrog>
If you want something version-y, when creating a new version of a directory you can add a .prev entry that points to the previous version of it, or similar
<epergny>
ToxicFrog: don't hesitate to correct the stupid things I may say... A few days ago I was asking questions, now I'm sharing hopefully correct infos : )
leolrrj has quit [Remote host closed the connection]
leolrrj has joined #ipfs
leolrrj has quit [Remote host closed the connection]
<ToxicFrog>
epergny: everything you said there looks accurate to me, but I'm a also pretty new at this
<dansup>
lgierth: ohai, just saw IPFS as the first result for a "smart" query. Looks like a wikipedia page :) https://i.dansup.xyz/103g3q323w0A
Have-Quick has quit [Quit: Have-Quick]
Have-Quick has joined #ipfs
smaddock has joined #ipfs
<TrUsT_n1>
Ok, no version-y stuff just different hashes. Got it. Just wanted to make sure there was not a feature I was missing and not using.
Have-Quick has quit [Client Quit]
smaddock has quit [Ping timeout: 265 seconds]
Have-Quick has joined #ipfs
badjoke_ has joined #ipfs
smaddock has joined #ipfs
<badjoke_>
How can Bitswap and FileCoin fit each other at future?look like they all have excitation mechanism...
<epergny>
badjoke_: excitation mechanism?
<badjoke_>
you know , they all have Reward and punishment system
smaddock has quit [Ping timeout: 240 seconds]
<badjoke_>
my bad English,don't mind>_<
<epergny>
badjoke_: oh you mean the incentive layer Filecoin shall provide on top of IPFS?
<badjoke_>
yes, and they both have Ledger too
<badjoke_>
Does that mean when IPFS work with FileCoin then they don't need Bitswap anymore?
<ToxicFrog>
TrUsT_n1: yeah, it's a copy-on-write merkle tree. You can put versioning on top of it but it's not an inherent feature.
<epergny>
ToxicFrog: imagine I were to, say, add the hash of the last entry every time I were to add something... Should I lose track of the last added hash, how could I find it back?
<epergny>
ToxicFrog: it's theoretical
<ToxicFrog>
epergny: like, you did an `ipfs add` and then misplaced the hash it gave you?
<ToxicFrog>
Hrm
<ToxicFrog>
If you still have the files you added, you can just re-add those and you'll get the hash back, but let's assume you didn't because you thought they were safe in IPFS after being added.
<epergny>
ToxicFrog: yup exactly that case...
<ToxicFrog>
`ipfs add` automatically pins, so `ipfs pin ls -t direct` will list it, but it will also list all your other direct pins and there aren't any ordering guarantees that would let you find the most recent one.
<epergny>
ToxicFrog: I mean... There are ways obviously but I wonder.
<ToxicFrog>
`-t recursive`, rather, since I think that's what `add` uses.
<epergny>
ToxicFrog: well, if you did religiously always add a "prev" file with the hash of the previous add, then it's kinda easy.
<epergny>
ToxicFrog: these kind of weird cases help me better understand how things work under the hood. And, well, may also same me someday : )
<ToxicFrog>
Oh, yeah
<ToxicFrog>
Sorry, I thought you mean "I just added something and forgot to record the hash"
<ToxicFrog>
But yeah, it also applies to "I added a thing and forgot the hash of the old version"
<epergny>
ToxicFrog: well if I just added it, as you said, I just re-add it.
<ToxicFrog>
But, yeah, it'll be in the pins, and if you still have the ipfsd logs from when you added it it might be recorded there
<ToxicFrog>
If you have a programmable way of recognizing when it's the right file, I'd probably just feed the output of `ipfs pin ls -t recursive -q` to that and see which one it finds
<epergny>
ToxicFrog: with the way IPFS work I realize if I want to I can write my own little wrapper around "ipfs add .." that does always wrap in a directory and put all the metadata I want in that directory. And then I can still link to the "inner" directory (say the one containing index.html or whatever).
<ToxicFrog>
Yeah, I do something similar except I don't much worry about metadata
<ToxicFrog>
It stores everything in a directory, and if there's a previous version it stuffs it into an old-versions directory that's datestamped
badjoke_ has quit [Quit: Page closed]
<epergny>
ToxicFrog: what language do you use for that? Shell script? Python? Go?
<TrUsT_n1>
ToxicFrog: After adding a file or dir to IPFS I use "ipfs files" to create a named structure of the files I have in ipfs.
<ToxicFrog>
TrUsT_n1: same
<ToxicFrog>
epergny: shell script. hang on, I think I put it on github
<epergny>
ToxicFrog: ah ah cool, I can't really access IPFS yet: haven't learned the networking part yet : )
<ToxicFrog>
The idea being that you can `share add [a bunch of files and/or directories]` and it'll stuff them into IPFS and return an HTTP gateway link
<ToxicFrog>
There's also `share add-zip` to zip a bunch of stuff and then share the zip file, and then `share ls` and `share rm` to manage the shares.
<epergny>
ToxicFrog: yup nice, was going to comment *precisely* on that : )
<epergny>
ToxicFrog: are the "ipfs files ..." stable and not too subject to changes?
<ToxicFrog>
epergny: I sure hope so, because I use them heavily!
<epergny>
ah ah : )
martinBrown has joined #ipfs
Have-Quick has quit [Quit: Have-Quick]
benjamingr_ has quit [Quit: Connection closed for inactivity]
God-Eater has joined #ipfs
God-Eater has quit [Client Quit]
<TrUsT_n1>
ToxicFrog: Same here. I would be in trouble if they pulled the files feature.
ericxtang has joined #ipfs
<lemmi>
i just wish we could add a comment when we pin something
<lemmi>
and that the filename is recorded aswell
<epergny>
lemmi: you can ask for what you add to be wrapped in a directory, then filename is preserved inside the directory
<lemmi>
sure ipfs files works, but it doesn't really help when you need to clean up your repo
<lemmi>
i'd almost be content if we had multiple ipfs files namespaces
<lemmi>
so you could have a pin namespace and not clutter the rest
<lemmi>
but i guess at the moment are bigger fish to fry
statemech has joined #ipfs
dimitarvp has quit [Quit: Bye]
user_51 has joined #ipfs
statemech has quit [Ping timeout: 268 seconds]
user51 has quit [Ping timeout: 268 seconds]
Adbray has quit [Quit: Quit]
DJ-AN0N has joined #ipfs
ericxtang has quit [Remote host closed the connection]
epergny has left #ipfs ["ERC (IRC client for Emacs 25.2.50.1)"]
zcstarr has joined #ipfs
leolrrj_ has joined #ipfs
SunflowerSociety has joined #ipfs
SunflowerSociety has quit [Changing host]
SunflowerSociety has joined #ipfs
ericxtang has joined #ipfs
leolrrj_ has quit [Ping timeout: 276 seconds]
ONI_Ghost has quit [Ping timeout: 260 seconds]
Adbray has joined #ipfs
reit has quit [Quit: Leaving]
sz0 has quit [Quit: Connection closed for inactivity]
Have-Quick has joined #ipfs
SunflowerSociety has quit [Read error: Connection reset by peer]
SunflowerSociety has joined #ipfs
ericxtang has quit [Remote host closed the connection]
ericxtang has joined #ipfs
shizy has joined #ipfs
ericxtang has quit [Remote host closed the connection]
ericxtang has joined #ipfs
shizy has quit [Ping timeout: 256 seconds]
Have-Quick has quit [Quit: Have-Quick]
ryjen_ has quit [Quit: ryjen_]
Guanin_ has quit [Ping timeout: 248 seconds]
Sunflowery has joined #ipfs
Guanin_ has joined #ipfs
SunflowerSociety has quit [Ping timeout: 240 seconds]
Have-Quick has joined #ipfs
TrUsT_n1 has quit [Ping timeout: 240 seconds]
ericxtang has quit [Remote host closed the connection]
ericxtang has joined #ipfs
jamiew has quit [Ping timeout: 250 seconds]
jamiew has joined #ipfs
ulrichard has joined #ipfs
ulrichard has quit [Remote host closed the connection]
rendar has joined #ipfs
leolrrj has joined #ipfs
ericxtang has quit [Remote host closed the connection]
Sunflowery has quit [Ping timeout: 265 seconds]
cam[m]1 is now known as cam[m]2
cam[m]2 is now known as cam[m]4
ulrichard has joined #ipfs
DJ-AN0N has quit [Quit: DJ-AN0N]
gmoro_ has joined #ipfs
gmoro has quit [Ping timeout: 256 seconds]
reit has joined #ipfs
inetic has joined #ipfs
Have-Quick has quit [Quit: Have-Quick]
Steverman has quit [Ping timeout: 255 seconds]
mathwetrust has joined #ipfs
mtodor has joined #ipfs
mathwetrust has quit [Client Quit]
daMaestro has quit [Quit: Leaving]
colatkinson has joined #ipfs
tglman1 has quit [Ping timeout: 256 seconds]
fazo96 has joined #ipfs
tglman1 has joined #ipfs
ericxtang has joined #ipfs
colatkinson has quit [Quit: colatkinson]
ericxtang has quit [Ping timeout: 264 seconds]
xzha has joined #ipfs
colatkinson has joined #ipfs
Steverman has joined #ipfs
bomb-on has quit [Quit: SO LONG, SUCKERS!]
satazor has joined #ipfs
Magik6k_ is now known as Magik6k
aapjeisbaas has joined #ipfs
Steverman has quit [Ping timeout: 255 seconds]
bomb-on has joined #ipfs
warner has joined #ipfs
Lymkwi has quit [Quit: No Ping reply in 180 seconds.]
Lymkwi has joined #ipfs
Trieste has quit [Ping timeout: 240 seconds]
plexigras has joined #ipfs
Trieste has joined #ipfs
cam[m]4 is now known as cam[m]6
Trieste has quit [Read error: Connection reset by peer]
bomb-on is now known as onkel
colatkinson has quit [Ping timeout: 240 seconds]
Trieste has joined #ipfs
Ecran has joined #ipfs
houdini_1775 has joined #ipfs
onkel is now known as bomb-on
<lgierth>
dansup: yeeeah ipfs wikipedia is really popular :D
<lgierth>
we're kind of cheating by having all kinds of stuff on the same domain
satazor has quit [Remote host closed the connection]
satazor has joined #ipfs
satazor has quit [Ping timeout: 240 seconds]
fazo96_ has joined #ipfs
fazo96 has quit [Ping timeout: 276 seconds]
xentec has quit [Quit: memento mori]
xentec has joined #ipfs
satazor has joined #ipfs
<r0kk3rz>
imo things like wikipedia are a great case for IPFS
satazor has quit [Ping timeout: 256 seconds]
cblgh has quit [Ping timeout: 246 seconds]
cblgh has joined #ipfs
cblgh has joined #ipfs
cblgh has quit [Changing host]
Sunflowery has joined #ipfs
achingbrain has joined #ipfs
Steverman has joined #ipfs
kaotisk_ has joined #ipfs
kaotisk has quit [Ping timeout: 264 seconds]
dimitarvp has joined #ipfs
tombusby has quit [Read error: Connection reset by peer]
joocain2 has quit [Read error: Connection reset by peer]
trqx has quit [Read error: Connection reset by peer]
tombusby has joined #ipfs
joocain2 has joined #ipfs
trqx has joined #ipfs
Ishtv4n has joined #ipfs
tombusby has quit [Remote host closed the connection]
joocain2 has quit [Remote host closed the connection]
joocain2 has joined #ipfs
tombusby has joined #ipfs
mazeto has joined #ipfs
AkhILman has quit [Remote host closed the connection]
kaotisk_ has quit [Ping timeout: 260 seconds]
cblgh has quit [Ping timeout: 264 seconds]
Panako has joined #ipfs
Panako has quit [Client Quit]
AkhILman has joined #ipfs
konubinix has quit [Remote host closed the connection]
Sunflowery has quit [Ping timeout: 268 seconds]
reit has quit [Quit: Leaving]
cblgh has joined #ipfs
houdini_1775 has quit [Read error: Connection reset by peer]
<Taoki>
Hi. Can anyon explain what the differences are between pin types? I see that pinning can be either direct, indirect, or recusrive. What are the differences?
Ecran has quit [Remote host closed the connection]
leolrrj has quit [Remote host closed the connection]
vmx has joined #ipfs
leolrrj has joined #ipfs
leolrrj has quit [Remote host closed the connection]
konubinix has joined #ipfs
leolrrj has joined #ipfs
Trieste has quit [Read error: Connection reset by peer]
astrofog has joined #ipfs
Trieste has joined #ipfs
astrofog has quit [Client Quit]
astrofog has joined #ipfs
Trieste has quit [Ping timeout: 240 seconds]
mrBen2k2k2k_ has quit [Remote host closed the connection]
Trieste has joined #ipfs
bomb-on is now known as onkel
onkel is now known as bomb-on
Steverman has quit [Quit: WeeChat 2.1]
<lgierth>
Taoki: recursive also pins the children (direct doesn't), and indirect means it's a child of a recursively pinned thing
<Taoki>
lgierth: How do files have children however? IIRC they're just data referenced by a hash.
<lgierth>
there's chunking
<lgierth>
and directory entries are also just children of a directory object
<lgierth>
try e.g. `ipfs object links /ipns/ipfs.io`
Guanin_ has quit [Remote host closed the connection]
<Taoki>
Oh wow. That does show file hashes connected to file and website names. I can't quite understand how these work however
<Taoki>
lgierth: I'd still like to understand how the children of a file are defined. How does a file know how another file is used in relation to it?
<ToxicFrog>
Basically, an IPFS object is a bunch of data (file contents; may be empty) and a bunch of links (a name => IPFS object map)
<ToxicFrog>
IPFS "directories" have empty data and a bunch of links to their contents.
<ToxicFrog>
When you use `add -w` or directory manipulation commands under `ipfs files`, that's what's happening.
<Taoki>
Interesting. Will have to see the exact rules of how this works, currently finding it hard to warp my mind around it entirely.
<ToxicFrog>
Taoki: try playing around with `ipfs files mkdir/mv/ls -l/stat` and then `ipfs object get` on the hashes that returns
<ToxicFrog>
That's an easy way to make some directories and see how they're represented internally.
<Taoki>
Oooh. So the immutable hash of a file points to its object, and that object then points to other data in one of its fields (like the file contents). Or does the object also store the data? I think it's the later.
<ToxicFrog>
You can also use `add -w`, which automatically wraps the added file(s) in a directory.
<Taoki>
Gah... I still feel bad for not knowing this stuff despire being a fan of IPFS for so long :P
<ToxicFrog>
For small files, you get a single object containing the data.
<Taoki>
Hmmm. I'm seeing that object hashes and file hashes are different things.
<Taoki>
Aha
<ToxicFrog>
For large files, they get split into chunks, and a top-level object is created with links pointing to all of those chunks in order
<Taoki>
Okay. And for larger files, the data of a file is referenced by one hash, but you work with the object of that file.
<Taoki>
Oooh. Fair enough
<ToxicFrog>
And you generally just refer to that top-level object, but there are commands to pry it open and look at individual chunks if you need to
<Taoki>
So the object of the file is a list of hashes pointing to various chunks of data.
<ToxicFrog>
Yeah.
<ToxicFrog>
And this also means deduplication can happen at the chunk level rather than the file level.
<Taoki>
Just curious: Do you get to decide how the chunks are split when uploading? Or what are the rules for that sort of thing?
<Taoki>
Like "a chunk per 10 MB" or something of the form?
<ToxicFrog>
Fun exercise: `dd if=/dev/zero bs=1M count=1 | ipfs add` and then `ipfs object get` the hash
<ToxicFrog>
You'll see it created a top-level object with links to four 256KB chunks -- and all four chunks are the same, since they all just contain 256KB of zeroes.
<ToxicFrog>
Taoki: default is chunk per 256KB. I believe there are options to adjust this but I haven't experimented with them.
<ToxicFrog>
Taoki: oh, you should look at `ipfs add --help`: -s, --chunker string - Chunking algorithm, size-[bytes] or rabin-[min]-[avg]-[max]. Default: size-262144.
<lemmi>
Taoki: i think largest chunk size is 2mb. this is currently a hardlimit since you can only verify a chunk once downloaded completely.
<lemmi>
at least i think it's 2mb
<Taoki>
I see. Thanks
<Taoki>
Wow though. If each chunk is 256 KB by default, gigabyte sized file could have millions of them.
<Taoki>
But I understand chunks is how different nodes can send you different bits of a content, so now it actually makes sense.
<Taoki>
I assumed those chunks are determined dynamically when reading a file, and the file was all a single lump of data.
<Taoki>
Out of curiosity: Once a file is uploaded, can you reupload it at a different number of chunks?
<lemmi>
if the chunk is different size, the content is different so the hash will be different
<ToxicFrog>
Taoki: the `rabin` chunker does it dynamically based on file contents, I believe
<lemmi>
which is why it makes sense to stick to the default. higher chance to hit something someone else already hosts
<lemmi>
i haven't had great results so far with this particular chunker.
<ToxicFrog>
Taoki: also, 256KB is pretty large, a 1GB file will only have 4k chunks.
<ToxicFrog>
To get up into millions you need 256GB
<Taoki>
Ahhh, good thinking. If you did "ipfs add" with a different chunk size, it would post a different file. Thanks :)
<Taoki>
Oh. I overestimated that then.
<Taoki>
Yeah 256 Kb sounds pretty good actually. For people with slow connections, it might be good to make sure each node can send you that much.
<Taoki>
Though that makes me wonder if perhaps the default chunk size should be divided into powers of two. So for small files it's 128kb, for larger ones 256kb, for even larger 512kb, and perhaps at most 1024kb (1 Mb). But it works fine either way so not important.
ashark has joined #ipfs
<lemmi>
for normal files 256kb is good. but what does pose a problem is mapping git repos into ipfs. at the moment you can't put arbitrarily large files into one chunk to retain the same hash as git
<lemmi>
so for the moment you are stuck with files smaller than 2mb
<Taoki>
Is the 2mb limit a decision, or a deep limitation in the system?
<lemmi>
it's a decision
<lemmi>
but git in ipfs will be so much fun
<Taoki>
Ok. With increased computing power and storage space, I imagine it can be lifted later on.
<Taoki>
Indeed! I just asked about that in a thread yesterday.
<Taoki>
Whether Git repositories will be possible to host in IPFS. I was told that it's planned.
<Taoki>
Especially if you can make it so that Github / Gitlab repos can be automatically mirrored onto IPFS as well.
<lemmi>
just push into ipfs, set an ipns entry for your head, pull from other people's repo ... to me this feels like this is how git was supposed to work
<lemmi>
you don't need github anymore
<lemmi>
no the git ipfs thing already works in parts
<Taoki>
Most repos are hosted on Github though, it might be useful to migrate. Also GH provides a HTML interface, for pull requests and the like.
smaddock has joined #ipfs
<r0kk3rz>
you neved *needed* github, it is useful though
Ishtv4n has quit [Ping timeout: 268 seconds]
<lemmi>
it'll stay useful for quite a while, even if git ipfs thing works perfectly. but i'm really liking the idea to host my private stuff this way
Ishtv4n has joined #ipfs
<Taoki>
I wonder if git for IPFS will become the way to host dynamic websites.
<Taoki>
Since that's one of the biggest questions with IPFS right now
<Taoki>
eg: How we'll build anything like Twitter or Facebook or a forum on top of it, having to rely on an IPNS domain for every little change.
<lemmi>
pubsub will help in this case, but i'm not holding my breath this is coming soon. small things like chats seem to work, but you always need some extra bit beside a normal ipfs node to actually work.
ericxtang has joined #ipfs
<r0kk3rz>
Taoki: dynamic websites need to talk ipfs with something like js-ipfs
<Taoki>
pubsub is nor permanent IIRC, that's part of the problem.
<Taoki>
And yeah: I'm just curious how much JavaScript on the browser side can do in place of a server.
<Taoki>
If only something like Nodejs / Meteor could run in IPFS itself and be processed by nodes. Modules like this would probably be complicated however.
<r0kk3rz>
not especially
Worldexe has joined #ipfs
Worldexe has quit [Max SendQ exceeded]
Worldexe has joined #ipfs
astrofog has quit [Quit: Quite]
Have-Quick has joined #ipfs
pguth64 has joined #ipfs
Have-Quick has quit [Quit: Have-Quick]
slawomir has joined #ipfs
<slawomir>
Hi
<slawomir>
In my opinion IPFS isn't aimed to use with HTML document, because it can change
<slawomir>
I have idea to make document change-aware
<slawomir>
Just use CVS
<slawomir>
And use two dates in resource identification
Caterpillar2 has joined #ipfs
<slawomir>
Date of document we have and target document date
<slawomir>
Imagine we visit on my_site.html 5th octomber
<slawomir>
And wanna to visit the latest version
<slawomir>
So we asks 5thoctomber <as timestamp> <hash> latest
<slawomir>
And that's all
<slawomir>
Hash reference to document version of 5th octomber
<slawomir>
Because documents are signed, we are sure we download correct document
<slawomir>
What do you think?
<slawomir>
I didn't read whole paper and I'm not good in IT (I have only bachelor degree)
ericxtang has quit [Remote host closed the connection]
ericxtang has joined #ipfs
}ls{ has joined #ipfs
<slawomir>
Sorry for my English
<slawomir>
Hash is hash of document in version form 5th octomber
<slawomir>
We access document by version_of_document_hash (by timestamp) hash and revision
<slawomir>
revision can be date
<slawomir>
So we also got Wayback Machine as additional effect
ericxtang has quit [Ping timeout: 268 seconds]
<slawomir>
Distributed Wayback Machine of course
ulrichard has quit [Remote host closed the connection]
raynold has quit []
<lemmi>
slawomir: look up what ipns can do for you
<slawomir>
Ok. Thanks
<slawomir>
And sorry if I describe functionality, which are present
<lemmi>
and if you want to version things you just can keep a directory with all versions, or, like git, always keep the previous version as a foldet in the current version
<fazo96_>
Taoki: a good solution is OrbitDB. It adds a permanent mutable data layer on top of IPFS/libp2p
ericxtang has joined #ipfs
<Taoki>
fazo96_: Very nice and worth remembering, should check that out.
<Taoki>
Thanks
bsm1175321 has joined #ipfs
<slawomir>
Sorry again. I read that IPFS uses hash and be little scary, because how to use it with HTML documents or other data we could to change. I will read more
<ToxicFrog>
slawomir: you can store entire directory heirarchies in it accessed through a single top-level hash, and you can also use IPNS to generate a hash that you can change what it points to
<ToxicFrog>
So generally you make sure your entire site is under a single directory, add that, getting a single hash, and then point an IPNS record at it; to publish a new version, you add the new version and update the IPNS record with the new top-level hash.
ericxtang has quit [Remote host closed the connection]
cmbrnt has joined #ipfs
<djdv>
something like this `ipfs add -r MyDir -Q | ipfs name publish --key=MyKey`
<slawomir>
How ipfs calculates hash for directories? It's probably not based on file names and inode numbers.
<lemmi>
slawomir: directories are "files" themselves. they map a filename to the hash of that file.
<slawomir>
Name of directory - correctly?
<slawomir>
Or just open directory, omits inode information and map file names that a directory contains
ericxtang has joined #ipfs
ericxtang has quit [Remote host closed the connection]
<slawomir>
I know in Unix systems directories are files, but on some Unix systems programs cannot open directories as files
<lemmi>
slawomir: forget unix
<lemmi>
slawomir: ipfs has nothing to do with inodes
<lemmi>
slawomir: in ipfs, directoris are nothing more than a table of filename->hash
<lemmi>
slawomir: that table is also, like a normal file, just a bunch of bytes. you put that bunch of bytes into the hash-function and you get the hash of the directory
<lemmi>
slawomir: this is all pretty awkward to explain. usually it gets clear if you play around with ipfs yourself. just add a folder, see what happens, with ipfs object get $HASH you can see what the content of a hash actually is
<slawomir>
Ok. I understood
<slawomir>
Thanks
sz0 has joined #ipfs
<slawomir>
Ok. I have read Getting Started (Movies are boring and I prefer to read than listen) and now I know public key are something like domain name
<lemmi>
you can use it like that, yes.
smaddock has quit [Ping timeout: 260 seconds]
jesse22 has joined #ipfs
Adbray has quit [Read error: Connection reset by peer]
Adbray has joined #ipfs
mtodor has quit [Remote host closed the connection]
Ishtv4n has quit [Ping timeout: 256 seconds]
reit has joined #ipfs
ericxtang has joined #ipfs
Encrypt has joined #ipfs
Caterpillar2 has quit [Quit: You were not made to live as brutes, but to follow virtue and knowledge.]
Steverman has joined #ipfs
ericxtang has quit [Remote host closed the connection]
ericxtang has joined #ipfs
ericxtan_ has joined #ipfs
ericxtang has quit [Remote host closed the connection]
inetic has quit [Ping timeout: 256 seconds]
Cavedude has quit [Ping timeout: 264 seconds]
Cavedude has joined #ipfs
<slawomir>
Thanks.
<slawomir>
How ipfs treads symbolic links
<slawomir>
I added an symbolic link from my project into my ipfs repo
xzha has quit [Ping timeout: 240 seconds]
<slawomir>
Use ipfs add -r ./link
<ToxicFrog>
It doesn't really
<slawomir>
Symbolic link points to an directory
<slawomir>
So it should been tread as normal directory
<slawomir>
I use ipfs ls hash
<slawomir>
And nothing are printed
fazo96_ has quit [Quit: Konversation terminated!]
<ToxicFrog>
IPFS doesn't handle symlinks well at all