2011-07-01 19:24:07 +00:00
|
|
|
{- git-annex presence log
|
|
|
|
|
-
|
|
|
|
|
- This is used to store presence information in the git-annex branch in
|
|
|
|
|
- a way that can be union merged.
|
|
|
|
|
-
|
|
|
|
|
- A line of the log will look like: "date N INFO"
|
2015-10-12 18:46:28 +00:00
|
|
|
- Where N=1 when the INFO is present, 0 otherwise.
|
2011-07-01 19:24:07 +00:00
|
|
|
-
|
deal better with clock skew situations, using vector clocks
* Deal with clock skew, both forwards and backwards, when logging
information to the git-annex branch.
* GIT_ANNEX_VECTOR_CLOCK can now be set to a fixed value (eg 1)
rather than needing to be advanced each time a new change is made.
* Misuse of GIT_ANNEX_VECTOR_CLOCK will no longer confuse git-annex.
When changing a file in the git-annex branch, the vector clock to use is now
determined by first looking at the current time (or GIT_ANNEX_VECTOR_CLOCK
when set), and comparing it to the newest vector clock already in use in
that file. If a newer time stamp was already in use, advance it forward by
a second instead.
When the clock is set to a time in the past, this avoids logging with
an old timestamp, which would risk that log line later being ignored in favor
of "newer" line that is really not newer.
When a log entry has been made with a clock that was set far ahead in the
future, this avoids newer information being logged with an older timestamp
and so being ignored in favor of that future-timestamped information.
Once all clocks get fixed, this will result in the vector clocks being
incremented, until finally enough time has passed that time gets back ahead
of the vector clock value, and then it will return to usual operation.
(This latter situation is not ideal, but it seems the best that can be done.
The issue with it is, since all writers will be incrementing the last
vector clock they saw, there's no way to tell when one writer made a write
significantly later in time than another, so the earlier write might
arbitrarily be picked when merging. This problem is why git-annex uses
timestamps in the first place, rather than pure vector clocks.)
Advancing forward by 1 second is somewhat arbitrary. setDead
advances a timestamp by just 1 picosecond, and the vector clock could
too. But then it would interfere with setDead, which wants to be
overrulled by any change. So it could use 2 picoseconds or something,
but that seems weird. It could just as well advance it forward by a
minute or whatever, but then it would be harder for real time to catch
up with the vector clock when forward clock slew had happened.
A complication is that many log files contain several different peices of
information, and it may be best to only use vector clocks for the same peice
of information. For example, a key's location log file contains
InfoPresent/InfoMissing for each UUID, and it only looks at the vector
clocks for the UUID that is being changed, and not other UUIDs.
Although exactly where the dividing line is can be hard to determine.
Consider metadata logs, where a field "tag" can have multiple values set
at different times. Should it advance forward past the last tag?
Probably. What about when a different field is set, should it look at
the clocks of other fields? Perhaps not, but currently it does, and
this does not seems like it will cause any problems.
Another one I'm not entirely sure about is the export log, which is
keyed by (fromuuid, touuid). So if multiple repos are exporting to the
same remote, different vector clocks can be used for that remote.
It looks like that's probably ok, because it does not try to determine
what order things occurred when there was an export conflict.
Sponsored-by: Jochen Bartl on Patreon
2021-08-03 20:45:20 +00:00
|
|
|
- Copyright 2010-2021 Joey Hess <id@joeyh.name>
|
2011-07-01 19:24:07 +00:00
|
|
|
-
|
2019-03-13 19:48:14 +00:00
|
|
|
- Licensed under the GNU AGPL version 3 or higher.
|
2011-07-01 19:24:07 +00:00
|
|
|
-}
|
|
|
|
|
|
2011-10-15 20:21:08 +00:00
|
|
|
module Logs.Presence (
|
2013-08-31 21:38:33 +00:00
|
|
|
module X,
|
2011-07-01 21:15:46 +00:00
|
|
|
addLog,
|
deal better with clock skew situations, using vector clocks
* Deal with clock skew, both forwards and backwards, when logging
information to the git-annex branch.
* GIT_ANNEX_VECTOR_CLOCK can now be set to a fixed value (eg 1)
rather than needing to be advanced each time a new change is made.
* Misuse of GIT_ANNEX_VECTOR_CLOCK will no longer confuse git-annex.
When changing a file in the git-annex branch, the vector clock to use is now
determined by first looking at the current time (or GIT_ANNEX_VECTOR_CLOCK
when set), and comparing it to the newest vector clock already in use in
that file. If a newer time stamp was already in use, advance it forward by
a second instead.
When the clock is set to a time in the past, this avoids logging with
an old timestamp, which would risk that log line later being ignored in favor
of "newer" line that is really not newer.
When a log entry has been made with a clock that was set far ahead in the
future, this avoids newer information being logged with an older timestamp
and so being ignored in favor of that future-timestamped information.
Once all clocks get fixed, this will result in the vector clocks being
incremented, until finally enough time has passed that time gets back ahead
of the vector clock value, and then it will return to usual operation.
(This latter situation is not ideal, but it seems the best that can be done.
The issue with it is, since all writers will be incrementing the last
vector clock they saw, there's no way to tell when one writer made a write
significantly later in time than another, so the earlier write might
arbitrarily be picked when merging. This problem is why git-annex uses
timestamps in the first place, rather than pure vector clocks.)
Advancing forward by 1 second is somewhat arbitrary. setDead
advances a timestamp by just 1 picosecond, and the vector clock could
too. But then it would interfere with setDead, which wants to be
overrulled by any change. So it could use 2 picoseconds or something,
but that seems weird. It could just as well advance it forward by a
minute or whatever, but then it would be harder for real time to catch
up with the vector clock when forward clock slew had happened.
A complication is that many log files contain several different peices of
information, and it may be best to only use vector clocks for the same peice
of information. For example, a key's location log file contains
InfoPresent/InfoMissing for each UUID, and it only looks at the vector
clocks for the UUID that is being changed, and not other UUIDs.
Although exactly where the dividing line is can be hard to determine.
Consider metadata logs, where a field "tag" can have multiple values set
at different times. Should it advance forward past the last tag?
Probably. What about when a different field is set, should it look at
the clocks of other fields? Perhaps not, but currently it does, and
this does not seems like it will cause any problems.
Another one I'm not entirely sure about is the export log, which is
keyed by (fromuuid, touuid). So if multiple repos are exporting to the
same remote, different vector clocks can be used for that remote.
It looks like that's probably ok, because it does not try to determine
what order things occurred when there was an export conflict.
Sponsored-by: Jochen Bartl on Patreon
2021-08-03 20:45:20 +00:00
|
|
|
addLog',
|
2015-10-12 18:46:28 +00:00
|
|
|
maybeAddLog,
|
2011-07-01 19:24:07 +00:00
|
|
|
readLog,
|
2014-02-06 16:43:56 +00:00
|
|
|
currentLog,
|
2015-04-01 21:53:16 +00:00
|
|
|
currentLogInfo,
|
|
|
|
|
historicalLogInfo,
|
2011-07-01 19:24:07 +00:00
|
|
|
) where
|
|
|
|
|
|
2013-08-31 21:38:33 +00:00
|
|
|
import Logs.Presence.Pure as X
|
2016-01-20 20:36:33 +00:00
|
|
|
import Annex.Common
|
2017-08-14 17:55:38 +00:00
|
|
|
import Annex.VectorClock
|
2011-10-04 04:40:47 +00:00
|
|
|
import qualified Annex.Branch
|
2014-02-06 16:43:56 +00:00
|
|
|
import Git.Types (RefDate)
|
2011-07-01 19:24:07 +00:00
|
|
|
|
deal better with clock skew situations, using vector clocks
* Deal with clock skew, both forwards and backwards, when logging
information to the git-annex branch.
* GIT_ANNEX_VECTOR_CLOCK can now be set to a fixed value (eg 1)
rather than needing to be advanced each time a new change is made.
* Misuse of GIT_ANNEX_VECTOR_CLOCK will no longer confuse git-annex.
When changing a file in the git-annex branch, the vector clock to use is now
determined by first looking at the current time (or GIT_ANNEX_VECTOR_CLOCK
when set), and comparing it to the newest vector clock already in use in
that file. If a newer time stamp was already in use, advance it forward by
a second instead.
When the clock is set to a time in the past, this avoids logging with
an old timestamp, which would risk that log line later being ignored in favor
of "newer" line that is really not newer.
When a log entry has been made with a clock that was set far ahead in the
future, this avoids newer information being logged with an older timestamp
and so being ignored in favor of that future-timestamped information.
Once all clocks get fixed, this will result in the vector clocks being
incremented, until finally enough time has passed that time gets back ahead
of the vector clock value, and then it will return to usual operation.
(This latter situation is not ideal, but it seems the best that can be done.
The issue with it is, since all writers will be incrementing the last
vector clock they saw, there's no way to tell when one writer made a write
significantly later in time than another, so the earlier write might
arbitrarily be picked when merging. This problem is why git-annex uses
timestamps in the first place, rather than pure vector clocks.)
Advancing forward by 1 second is somewhat arbitrary. setDead
advances a timestamp by just 1 picosecond, and the vector clock could
too. But then it would interfere with setDead, which wants to be
overrulled by any change. So it could use 2 picoseconds or something,
but that seems weird. It could just as well advance it forward by a
minute or whatever, but then it would be harder for real time to catch
up with the vector clock when forward clock slew had happened.
A complication is that many log files contain several different peices of
information, and it may be best to only use vector clocks for the same peice
of information. For example, a key's location log file contains
InfoPresent/InfoMissing for each UUID, and it only looks at the vector
clocks for the UUID that is being changed, and not other UUIDs.
Although exactly where the dividing line is can be hard to determine.
Consider metadata logs, where a field "tag" can have multiple values set
at different times. Should it advance forward past the last tag?
Probably. What about when a different field is set, should it look at
the clocks of other fields? Perhaps not, but currently it does, and
this does not seems like it will cause any problems.
Another one I'm not entirely sure about is the export log, which is
keyed by (fromuuid, touuid). So if multiple repos are exporting to the
same remote, different vector clocks can be used for that remote.
It looks like that's probably ok, because it does not try to determine
what order things occurred when there was an export conflict.
Sponsored-by: Jochen Bartl on Patreon
2021-08-03 20:45:20 +00:00
|
|
|
{- Adds to the log, removing any LogLines that are obsoleted. -}
|
|
|
|
|
addLog :: Annex.Branch.RegardingUUID -> RawFilePath -> LogStatus -> LogInfo -> Annex ()
|
|
|
|
|
addLog ru file logstatus loginfo =
|
|
|
|
|
addLog' ru file logstatus loginfo =<< currentVectorClock
|
|
|
|
|
|
|
|
|
|
addLog' :: Annex.Branch.RegardingUUID -> RawFilePath -> LogStatus -> LogInfo -> CandidateVectorClock -> Annex ()
|
|
|
|
|
addLog' ru file logstatus loginfo c =
|
|
|
|
|
Annex.Branch.change ru file $ \b ->
|
|
|
|
|
let old = parseLog b
|
|
|
|
|
line = genLine logstatus loginfo c old
|
|
|
|
|
in buildLog $ compactLog (line : old)
|
2011-07-01 21:15:46 +00:00
|
|
|
|
2015-10-12 18:46:28 +00:00
|
|
|
{- When a LogLine already exists with the same status and info, but an
|
|
|
|
|
- older timestamp, that LogLine is preserved, rather than updating the log
|
|
|
|
|
- with a newer timestamp.
|
|
|
|
|
-}
|
deal better with clock skew situations, using vector clocks
* Deal with clock skew, both forwards and backwards, when logging
information to the git-annex branch.
* GIT_ANNEX_VECTOR_CLOCK can now be set to a fixed value (eg 1)
rather than needing to be advanced each time a new change is made.
* Misuse of GIT_ANNEX_VECTOR_CLOCK will no longer confuse git-annex.
When changing a file in the git-annex branch, the vector clock to use is now
determined by first looking at the current time (or GIT_ANNEX_VECTOR_CLOCK
when set), and comparing it to the newest vector clock already in use in
that file. If a newer time stamp was already in use, advance it forward by
a second instead.
When the clock is set to a time in the past, this avoids logging with
an old timestamp, which would risk that log line later being ignored in favor
of "newer" line that is really not newer.
When a log entry has been made with a clock that was set far ahead in the
future, this avoids newer information being logged with an older timestamp
and so being ignored in favor of that future-timestamped information.
Once all clocks get fixed, this will result in the vector clocks being
incremented, until finally enough time has passed that time gets back ahead
of the vector clock value, and then it will return to usual operation.
(This latter situation is not ideal, but it seems the best that can be done.
The issue with it is, since all writers will be incrementing the last
vector clock they saw, there's no way to tell when one writer made a write
significantly later in time than another, so the earlier write might
arbitrarily be picked when merging. This problem is why git-annex uses
timestamps in the first place, rather than pure vector clocks.)
Advancing forward by 1 second is somewhat arbitrary. setDead
advances a timestamp by just 1 picosecond, and the vector clock could
too. But then it would interfere with setDead, which wants to be
overrulled by any change. So it could use 2 picoseconds or something,
but that seems weird. It could just as well advance it forward by a
minute or whatever, but then it would be harder for real time to catch
up with the vector clock when forward clock slew had happened.
A complication is that many log files contain several different peices of
information, and it may be best to only use vector clocks for the same peice
of information. For example, a key's location log file contains
InfoPresent/InfoMissing for each UUID, and it only looks at the vector
clocks for the UUID that is being changed, and not other UUIDs.
Although exactly where the dividing line is can be hard to determine.
Consider metadata logs, where a field "tag" can have multiple values set
at different times. Should it advance forward past the last tag?
Probably. What about when a different field is set, should it look at
the clocks of other fields? Perhaps not, but currently it does, and
this does not seems like it will cause any problems.
Another one I'm not entirely sure about is the export log, which is
keyed by (fromuuid, touuid). So if multiple repos are exporting to the
same remote, different vector clocks can be used for that remote.
It looks like that's probably ok, because it does not try to determine
what order things occurred when there was an export conflict.
Sponsored-by: Jochen Bartl on Patreon
2021-08-03 20:45:20 +00:00
|
|
|
maybeAddLog :: Annex.Branch.RegardingUUID -> RawFilePath -> LogStatus -> LogInfo -> Annex ()
|
|
|
|
|
maybeAddLog ru file logstatus loginfo = do
|
|
|
|
|
c <- currentVectorClock
|
|
|
|
|
Annex.Branch.maybeChange ru file $ \b ->
|
|
|
|
|
let old = parseLog b
|
|
|
|
|
line = genLine logstatus loginfo c old
|
|
|
|
|
in do
|
|
|
|
|
m <- insertNewStatus line $ logMap old
|
|
|
|
|
return $ buildLog $ mapLog m
|
|
|
|
|
|
|
|
|
|
genLine :: LogStatus -> LogInfo -> CandidateVectorClock -> [LogLine] -> LogLine
|
|
|
|
|
genLine logstatus loginfo c old = LogLine c' logstatus loginfo
|
|
|
|
|
where
|
|
|
|
|
oldcs = map date (filter (\l -> info l == loginfo) old)
|
|
|
|
|
c' = advanceVectorClock c oldcs
|
2015-10-12 18:46:28 +00:00
|
|
|
|
2011-07-01 19:24:07 +00:00
|
|
|
{- Reads a log file.
|
|
|
|
|
- Note that the LogLines returned may be in any order. -}
|
2019-11-26 19:27:22 +00:00
|
|
|
readLog :: RawFilePath -> Annex [LogLine]
|
2012-06-29 14:00:05 +00:00
|
|
|
readLog = parseLog <$$> Annex.Branch.get
|
2011-07-01 19:24:07 +00:00
|
|
|
|
|
|
|
|
{- Reads a log and returns only the info that is still in effect. -}
|
2019-11-26 19:27:22 +00:00
|
|
|
currentLogInfo :: RawFilePath -> Annex [LogInfo]
|
2015-04-01 21:53:16 +00:00
|
|
|
currentLogInfo file = map info <$> currentLog file
|
|
|
|
|
|
2019-11-26 19:27:22 +00:00
|
|
|
currentLog :: RawFilePath -> Annex [LogLine]
|
2015-04-01 21:53:16 +00:00
|
|
|
currentLog file = filterPresent <$> readLog file
|
2014-02-06 16:43:56 +00:00
|
|
|
|
|
|
|
|
{- Reads a historical version of a log and returns the info that was in
|
|
|
|
|
- effect at that time.
|
|
|
|
|
-
|
|
|
|
|
- The date is formatted as shown in gitrevisions man page.
|
|
|
|
|
-}
|
2019-11-26 19:27:22 +00:00
|
|
|
historicalLogInfo :: RefDate -> RawFilePath -> Annex [LogInfo]
|
2015-04-01 21:53:16 +00:00
|
|
|
historicalLogInfo refdate file = map info . filterPresent . parseLog
|
2014-02-06 16:43:56 +00:00
|
|
|
<$> Annex.Branch.getHistorical refdate file
|