[jump to content][No Software Patents] Tools (new) : Looking into a tool [ Home | Scylla+Charybdis old home | Tools (old) | Tools (new) | FAQ | Downloads ]
      Name                    Last modified       Size  Description

[DIR] Parent Directory 05-Jan-2009 18:48 - [DIR] GAT/ 05-Jan-2009 18:48 - [DIR] tino/ 05-Jan-2009 18:48 - [TXT] ANNOUNCE 26-Apr-2005 00:56 1k [TXT] COPYING 15-Apr-2005 22:52 18k [TXT] ChangeLog 16-Apr-2005 01:15 1k [TXT] DESCRIPTION 16-Apr-2005 01:25 1k [TXT] IDEAS 16-Apr-2005 02:27 1k [TXT] Makefile 25-Apr-2005 15:35 3k [TXT] Makefile.tino 24-Apr-2005 15:08 1k [TXT] README 26-Apr-2005 01:03 11k [TXT] TODO 16-Apr-2005 01:10 1k [TXT] VERSION 16-Apr-2005 01:16 1k [TXT] gat-cmds.h 25-Apr-2005 15:29 1k [TXT] gat-exitcodes.h 16-Apr-2005 01:45 1k [TXT] gat-lib.h 26-Apr-2005 00:54 6k [TXT] gat.c 25-Apr-2005 19:01 3k

$Header$

Status:
-------

This is vaporware today, just a placeholder.


What is GAT?
------------

Linus Torvalds wrote GIT, the File Manager From Hell.  GIT is ingenous
in how it treats files.  However it has some slight flaws, which made
it impossible for me to use it out of the box:

- GIT uses zlib as an implicite compression.  I consider zlib a
security risk, as in the past, several flaws in zlib were detected
(from archive bombs over buffer overruns to denial of service
conditions).  Also, zlib makes it a complex task to use a better or
other compression techniques, also the resulting files are not
readable by a native tool like /bin/cat.  Therefor GAT uses no
compression at all.  However in a future, it will allow compressed
file store.
 
- GIT stores it's repository under a directory .git.  That is not ok
for me.  I need the files to reside on a central repository on my
computer, such that it's more easy to write sync jobs for this.  So
GAT has an implicite default repository in the environment variable
GATROOT (which defaults to "~/.GATROOT/" under Unix and 'C:\GATROOT\'
under Windows).  If you want this to point somewhere else, just set
this variable or use a softlink.  GAT is NFS aware.

- GIT uses one global .git directory for everything.  However I
personally like how CVS treats it, such that you can share the same
directory under several trees without fear.  Therefor I have a GAT
directory in each directory (it does not start with a dot, as this is
inconvenient under some operating systems which have no Unix like
filesystem).

- GIT works with changesets, however I like the CVS way of 'tagging'.
Therefor GAT tries to resemble this type of CVS tagging, with naming
the GAT trees.

- GIT does not support CVS tags.  However I like how the CVS tags
work.  So I added this to GAT (at least, I will add this to GAT).

- GIT uses SHA-1.  I am more fond of MD5, as this is wider available
on more platforms (there are even implementations for Microsoft Visual
Basic).

- GIT does not use the plain file, as it writes a nifty header to it.
As you always can guess this header, GAT includes this header in the
MD5 hash calculation.  This way, after loading the file, it fails the
MD5 hash if it's not of the right type.  Note that the type is encoded
in the file name as well, such that you can easily check it from
shell.  This way, on CDROM, the GAT file repository and the unpacked
source code can share the same data and they can be hardlinked on a
readonly repository publishing area.

- GIT uses mmap().  That's clever, but I hate it, because I want to be
able to process files with arbitrary length.  Therefor GAT uses normal
file IO.

Perhaps more to follow later.


What is that name "GAT"?
------------------------

This is no name.  It's just a variant of GIT with I replaced by A,
because its pronounciation is more like "get" and similarily is no
usual english word, so it cannot be mistaken for one.

Also I like it, that it's very near 'cat', as implicitely GAT uses
a lot of features from cat (like unaltered cleartext files).


I don't want look at GIT, so what does GAT?
-------------------------------------------

GAT is a basic layer of an VCS.  It can replace CVS.  It can replace
Subversion.  There is no fancy UI, but you can trust in GAT, that it
keeps your valuables as safe as possible.

It works internally much like GIT, so to understand how GAT ensures
the integrity of everything you should read what Linus Torvalds writes
about GIT.  His words are ingenious and contain a deep secret.

If you interested in how to use GAT, there is a short HowTo in the
following text.  It helps, if you know CVS.

Prerequisites:
--------------

You need curl to build gat.


INSTALL:
--------

curl http://www.scylla-charybis.com/downloads/gat.tgz | gtar xfz -
cd gat
make
./gat update
make
make test
make install

Note that you will get "release" versions of GAT in this case.
Release versions are considered stable code.  If you want release
early code, you have to switch to a different "branch" using "gat
branch".


Command overview:
-----------------

NOTE THAT THIS SHOWS THE FUTURE.  NOT EVERYTHING IS IMPLEMENTED TODAY.

Most commands which have no parameters allow you to give a file list
to use this command only on the file list.  However, as the nature of
GAT, nearly any circumstance can be autodetected, so you usually do
not need to enter anything.

gat sync
	This does a synchronization with the repository keepers(s).
	In case you have only read access, this means, only new
	patches are downloaded.  Your patches are always uploaded to
	private keepers, and published patches are uploaded to public
	keepers, too.
	Note that 'gat update' implies 'gat sync' in case you have no
	local repository set up yet for this branch.

gat help
	Show help
gat help <command>
	Show help of command

gat branch
	List all branches.  Note that this list can become very big.

gat branch name
	Switch to another branch.  Don't forget to use "gat update".
	If name contains wildcards the branch is searched for.
	Branches are: HEAD, ALPHA, BETA, GAMMA, PRE, RELEASE, STABLE
	Several developers can publish their own branches.
	You can mix branches by concatenating with +, so
	gat branch RELEASE+HEAD(tino)
	says, that you want the release branch, but code from the
	head branch of tino, too.  This probably means, you are tino
	in a bigger project.
	For your own projects, just stick to HEAD (your author is
	implicitely added).
	Some hints: Use lower case letters if you want to 'name' a
	branch.  Branch names can include any valid character for
	eMail and domain, with the exception of the '+' (which is
	perfectly valid for eMail names) and must not start with a -.

gat branch +xxx
gat branch -xxx
	Add and remove a branch.
	Note that you can enter branches, which are unreachable.  For
	example if some author forks of a branch from release and you
	want to have something from the author from the beta branch,
	this might lead to nothing valid.

gat merge branch
	Merge the current version with the given branch.  Note that
	this implies, that you have access to the branch can commit to
	this branch.  Afterwards you have to commit, as you have
	switched the branch implicitely.

gat diff
	Show diff of current directory with selected branch.
gat status
	Like 'diff', only shorter.

gat ignore
	Show the ignores

gat ignore filemask
	This shows which files are ignored.  Beware of shell
	metacharacters, as "gat ignore *.c" works perfectly well, but
	what you meant was probably "gat ignore '*.c'", which
	basically is the same (in this case, GAT expands it for you).

gat ignore +filemask
gat ignore -filemask
	Add or remove ignores.  This probably works well with shell
	meta characters, as "gat ignore +*.c" usually does expand to
	"+*.c", as you seldomly have files starting with a +.

gat text
	Shows which files are considered text.  Well, gat works well
	without text.  The only difference between text and non-text
	files is, that CVS-sequences ($Header$ etc.) are replaced by
	auto generated values and line endings (CR, CR LF, LF) are
	converted to the machine standard.  Note that you need not to
	worry about files to be text or non-text, as they always are
	checked in binary.  So if you accidentially checked out a
	binary file in text mode you can fix this by setting it
	non-text and checkout again.

gat text filemask
	Like "gat ignore filemask" only for text

gat text +filemask
gat text -filemask
	Treat files as text, implicitely (+) or as non-text (-).

gat co
gat update
	Update the local directory with the data from the repository.
	Note that you need to use "sync" in case you have added this
	project to your local repository.  GAT will tell you if you
	probably need to sync.

gat ci
gat commit
	Update the GAT repository.  Note that you need write access to
	a repository for this.  You always have write access to your
	local repository, however it might be, that you have not
	initialized it, so this will tell you and fail.
	Note that you can ci/co individual files, too.  All files
	checked in together form a changeset.

gat author
gat trust
	Shows who currently is author for the changes and who you
	trust.

gat author name
	Set an author and implicitely trust this author.
	Note that you might get into trouble if this author is not
	globally unique.  So perhaps use your eMail address or a
	fake(!) eMail address which belongs to you as the author.
	Note that you can switch between authors easily.  You can only
	set an author if you are this author.  Authors may be
	protected by an implicite or explicite passphrase.  If it's
	implicite, this means, you have to enter it when you use 'gat
	author', else you have to use 'gat sign'.
	Beware!  Explicite passphrases are stored on disk and may
	leak.  Never use explicite passphrases on multi user systems,
	YOU HAVE BEEN WARNED.

gat trust +name
gat trust -name
	Trust or untrust author.  Note that 'trust' is an alias for
	'author'.  Only patchsets are downloaded of authors you trust.

gat sign
	Signs the current version.  This is only needed if the author
	is protected by a passphrase and the passphrase is 'explicite'.
	then you have to enter the passphrase now.
	Note that "publish" implicitely calls sign.
	Also note, that you always can 'commit' without signing, as
	this goes to your local repository.

gat publish
	If you are satisfied what you have, you can publish your code
	using this command.  This means, 'gat sync' will sync this
	with public masters, too.
	Note, that his calls 'gat sign' if needed.
	Note that this automagically calls 'gat sync', however you can
	interrupt the publishing at any time if you want, as 'gat
	sync' continues where you left off.

Following commands are redundant.  They are only needed to make life
more safe, just in case you accidentially delete something or such.

gat add
	Commit the add of files/directories.
gat remove
	Commit the remove of files/directories.
gat rename
	Commit the rename of files or directories.  This is black
	magic and often gets it wrong.  'rename' can be archived using
	'remove' and 'add' as well, as there is nothing like a real
	'rename tracking'.  It's just a convenience function.

Note that you do not need this commands, as you can switch it
implicitely for commit.  But this needs discipline on your side.


Logging
-------

There is an ever growing file "GATLOG", which is written such, that it
can be listed using 'tac GATLOG | less'.  If you use less directly, it
will look a little bit funny.

You can remove the file, it will always be created and appended.


License:
--------

GAT is code under the GNU GPL v2 or higher.  Read COPYING.

All GAT data structures and scripts which might show up under GAT
directories are free of any copyright.  So you can use GAT for
commercial purpose, it has no impact to you code which you develop
with the help of GAT.

-Tino
$Log$