tsuru / gandalf

Gandalf is an HTTP API for managing Git repositories.

Gandalf

Gandalf is a REST API written in Go to manage Git repositories, users and provide access to them over SSH.

YOU SHALL NOT PASS!

First steps:

• Installation guide
• Quickstart tutorial

Get involved:

• Contribute
• Community

For more information see the documentation

gandalf's Issues

user: AddKey should return error on duplicate key insertion

command to check whether a user has permission to read/write a repository

If the user has permission to read/write the repository, the code should execute the user's original command, this can be done using the SSH_ORIGINAL_COMMAND environment variable.

If not, the command should return an permission error.

It is important to notice that this command will be called only when the user tries to establish a ssh connection using the git user.

create init script for webserver

repository: implement BulkGrantAccess

e.g.:

repository.BulkGrantAccess("username", []repository.Repository{...})

port to bind webserver should be configurable

gandalf.conf: group bare configs

It should be something like:

bare-repositories:
    location: /var/repositories
    template: /home/git/tmpl

key: format key should pass user name to gandalf cmd

The command located at bin/gandalf.go expects to receive the user name as a cmd line argument, this depends on the key wrapping.

Write user's key in authorized_keys

When a user is added, should write his/her key to the authorized_keys.

remove key from authorized_keys file

key: move pkg files into user pkg

There's no need to a separate pkg exist.

Also, it is better if there is no exported actions in the pkg key, since the actions on it are applied only into authorized_keys file and do not reflect in gandalf's database.

handler: delete an user

Should delete the user and it's associations with projects.

handler: RemoveRepository returns success msg even on failure

$> curl -XDELETE ec2-54-242-108-5.compute-1.amazonaws.com:8080/repository/name
Could not remove repository: not found
Repository name successfuly removed(gandalf)

repository: replace isPublic field by file in git bare

Now that we're using git daemon to serve public operations, we need git daemon to know whether a repository is public or not, for that, when Gandalf receives the isPublic field, instead of saving the information in the database, it should create the related file in order to make it public for git daemon

handler: revoke user's access to read/write to repository

handler: remove repository

handler: remove key

By it's name

handler: list keys

The user should have a way to know how many keys he/she has, and what are their names.

repository: implement BulkRevokeAccess

e.g.:

repository.BulkRevokeAccess("username", []repository.Repository{...})

key: Remove does not removes from file

When removing a user via api, the user's key is not removed from authorized_keys file.

new repository should create git bare

bin: remove ' of repository path

Gandalf currently executes the original command around quotes, e.g:

git-receive-pack '/var/repositories/myproj.git'

This gives an error when executed via golang, it is needed to remove the single quotes.

repository: improve message when repository already exists

Today we're just repassing mongodb's error message, we should improve it

git-daemon export-all flag

It should be possible to start git-daemon (via gandalf) exporting all repositories by default.

Gandalf shold have a configuration flag, e.g.:

git-daemon:
    export-all: true

Project should have an user

should support custom hooks for bare repositories

We could support it using a template for bare repositories that already come with the hooks on it.

Or it could be a config flag pointing to a file, like

gandalf.conf

post-receive: path/to/executable

I'd rather the conf option.

bin: create struct to centralize command informations

Some informations are collected every time they're needed from SSH_ORIGINAL_COMMAND, we could store the processed informations in a struct, like:

type originalCmd struct {
    action string
    repositoryName
    ...
}

user: GrantAccess method

This method should add the user name in the repository's user list at mongodb

handler: add key

A key must have a name and it's content must be unique.

user: Remove error is not formatted

It just returns the error, for example, a not found is returned as "not found", while it should be "Could not remove user: not found"

scaling problem

Gandalf does not support scaling over more than one machine because of the authorized_keys file.

In order to have more than one server, Gandalf must share (?) the authorized_keys files over each server.

Maybe doozer is a great tool for that.

user: remove key struct

We could use only a map for the use we have.

api: use user.GrantAccess in GrantAccess handler

bin: repass messages to end user

For example, when a user pushes into an absent repository, the message returned by the server is:

fatal: The remote end hung up unexpectedly

This happens for all commands that executes with error in the server side.

user: RevokeAccess method

This method should remove the username from the repository user's list in mongodb

repository: remove bare

bin: log actions

It is impossible to debug this module right now, logs would help a lot

handler: remove repository

bin: append repository-path before execute SSH_ORIGINAL_COMMAND

For example, a

$> git push

with the remote set as [email protected]:myproject.git will execute the following command at githost.com:

$> git-receive-pack 'myproject.git'

but our repository path is not the git user's home, so we should run git-receive-pack passing the absolute path to the repository, e.g.:

$> git-receive-pack '/var/repositories/myproject.git'

handler: authorize user to read/write to repository

Wrapper to database session

We must have a wrapper to manage database sections, we can copy tsuru's interface:

db.Session.Repository().Action()

key: should have name

A key is only a string, it should be a struct with a name and the key itself.

log actions

In the present moment, we do not log any kind of actions.

It would be nice if we started logging. It would be awesome if we also have log levels (error, warning, info and debug)

api authentication

gandalf should need authentication to respond for actions via api.

api: handlers for repository.BulkGrantAccess and repository.BulkRevokeAccess

user: AddKey method

It should be possible to append keys to existent users, e.g:

u.AddKey("ssh-rsa somekey...")

This method should add the key into the user document at mongodb and write it at authorized_keys file.

api: return git remote on repository creation

repository: bare creation does not add .git in the dir name

If gandalf is requested to created a repository, the bare should be called 'reponame.git', the '.git' part is missing.

start git daemon on initialization

It might be done on web server start up inside the main function, or by the install script, that already starts gandalf-webserver.

I'd rather the startup on main approach, mainly because we need to pass a --base-path config that resides on gandalf.conf file. Other good point for that approach is that if the user does not uses the install script to install/start gandalf he/she will not be forced to start git-daemon manually.

key: lock authorized_keys files when writting

Simply using the syscall.O_EXLOCK should solve the issue.

Something like https://gist.github.com/4034318 should do the trick.

wrap ssh key with custom confs

We should ensure that the user cannot write into repositories which he/she has no permission to do so.
We should also ensure that the user cannot freely login into the server using the git user, and not execute any command different from the binary that we're gonna create.

Something like:

no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty,command=
"/path/to/cmd or binary name (in PATH)" ssh-rsa AAAAB3NzaC1kc3MAAACBAOjv4TL4EbQ(...)

This issue depends on issue #12.