def main(argv=sys.argv):
"""Entry point for starting a TCP git server."""
import optparse
parser = optparse.OptionParser()
parser.add_option("-l",
"--listen_address",
dest="listen_address",
default="localhost",
help="Binding IP address.")
parser.add_option("-p",
"--port",
dest="port",
type=int,
default=TCP_GIT_PORT,
help="Binding TCP port.")
options, args = parser.parse_args(argv)
log_utils.default_logging_config()
if len(args) > 1:
gitdir = args[1]
else:
gitdir = '.'
# TODO(jelmer): Support git-daemon-export-ok and --export-all.
backend = FileSystemBackend(gitdir)
server = TCPGitServer(backend, options.listen_address, options.port)
server.serve_forever()
def cmd_daemon(args):
"""Entry point for starting a TCP git server."""
import optparse
parser = optparse.OptionParser()
parser.add_option("-l", "--listen_address", dest="listen_address",
default="127.0.0.1",
help="Binding IP address.")
parser.add_option("-p", "--port", dest="port", type=int,
default=TCP_GIT_PORT,
help="Binding TCP port.")
parser.add_option("-c", "--swift_config", dest="swift_config",
default="",
help="Path to the configuration file for Swift backend.")
options, args = parser.parse_args(args)
try:
import gevent
import geventhttpclient
except ImportError:
print("gevent and geventhttpclient libraries are mandatory "
" for use the Swift backend.")
sys.exit(1)
import gevent.monkey
gevent.monkey.patch_socket()
from dulwich.contrib.swift import load_conf
from dulwich import log_utils
logger = log_utils.getLogger(__name__)
conf = load_conf(options.swift_config)
backend = SwiftSystemBackend(logger, conf)
log_utils.default_logging_config()
server = TCPGitServer(backend, options.listen_address,
port=options.port)
server.serve_forever()
def main(argv=sys.argv):
"""Entry point for starting an HTTP git server."""
import optparse
parser = optparse.OptionParser()
parser.add_option("-l", "--listen_address", dest="listen_address",
default="localhost",
help="Binding IP address.")
parser.add_option("-p", "--port", dest="port", type=int,
default=8000,
help="Port to listen on.")
options, args = parser.parse_args(argv)
if len(args) > 1:
gitdir = args[1]
else:
gitdir = os.getcwd()
log_utils.default_logging_config()
backend = DictBackend({'/': Repo(gitdir)})
app = make_wsgi_chain(backend)
server = make_server(options.listen_address, options.port, app,
handler_class=WSGIRequestHandlerLogger,
server_class=WSGIServerLogger)
logger.info('Listening for HTTP connections on %s:%d',
options.listen_address, options.port)
server.serve_forever()
def main(argv=sys.argv):
"""Entry point for starting an HTTP git server."""
import optparse
parser = optparse.OptionParser()
parser.add_option("-l", "--listen_address", dest="listen_address",
default="localhost",
help="Binding IP address.")
parser.add_option("-p", "--port", dest="port", type=int,
default=8000,
help="Port to listen on.")
options, args = parser.parse_args(argv)
if len(args) > 1:
gitdir = args[1]
else:
gitdir = os.getcwd()
log_utils.default_logging_config()
backend = DictBackend({'/': Repo(gitdir)})
app = make_wsgi_chain(backend)
server = make_server(options.listen_address, options.port, app,
handler_class=WSGIRequestHandlerLogger,
server_class=WSGIServerLogger)
logger.info('Listening for HTTP connections on %s:%d',
options.listen_address, options.port)
server.serve_forever()
def handle(self, *args, **options):
log_utils.default_logging_config()
address = '0.0.0.0'
port = 9418
backend = DjangitFileSystemBackend(settings.DJANGIT_REPOS_DIR)
server = TCPGitServer(backend, address, port)
server.serve_forever()
def run(self, args):
from dulwich import log_utils
parser = optparse.OptionParser()
parser.add_option("-l",
"--listen_address",
dest="listen_address",
default="",
help="Binding IP address.")
parser.add_option("-p",
"--port",
dest="port",
type=int,
default=8000,
help="Binding TCP port.")
options, args = parser.parse_args(args)
log_utils.default_logging_config()
if len(args) >= 1:
gitdir = args[0]
else:
gitdir = '.'
from dulwich import porcelain
porcelain.web_daemon(gitdir,
address=options.listen_address,
port=options.port)
def run(self, args):
from dulwich import log_utils
from dulwich.protocol import TCP_GIT_PORT
parser = optparse.OptionParser()
parser.add_option(
"-l",
"--listen_address",
dest="listen_address",
default="localhost",
help="Binding IP address.",
)
parser.add_option(
"-p",
"--port",
dest="port",
type=int,
default=TCP_GIT_PORT,
help="Binding TCP port.",
)
options, args = parser.parse_args(args)
log_utils.default_logging_config()
if len(args) >= 1:
gitdir = args[0]
else:
gitdir = "."
porcelain.daemon(gitdir, address=options.listen_address, port=options.port)
def main(argv=sys.argv):
"""Entry point for starting a TCP git server."""
MysqlRepo.setup(os.environ['DB_URL'])
log_utils.default_logging_config()
repos = MysqlRepo.list_repos()
backendDict = { '/%s' % repo: MysqlRepo.open(repo) for repo in repos }
backend = DictBackend(backendDict)
server = TCPGitServer(backend, '0.0.0.0')
server.serve_forever()
def main(argv=sys.argv):
"""Entry point for starting a TCP git server."""
if len(argv) > 1:
gitdir = argv[1]
else:
gitdir = '.'
log_utils.default_logging_config()
backend = DictBackend({'/': Repo(gitdir)})
server = TCPGitServer(backend, 'localhost')
server.serve_forever()
def main(argv=sys.argv):
"""Entry point for starting a TCP git server."""
if len(argv) > 1:
gitdir = argv[1]
else:
gitdir = '.'
log_utils.default_logging_config()
backend = DictBackend({'/': Repo(gitdir)})
server = TCPGitServer(backend, 'localhost')
server.serve_forever()
def main(argv=sys.argv):
"""Entry point for starting a TCP git server."""
import optparse
parser = optparse.OptionParser()
parser.add_option("-l", "--listen_address", dest="listen_address", default="localhost", help="Binding IP address.")
parser.add_option("-p", "--port", dest="port", type=int, default=TCP_GIT_PORT, help="Binding TCP port.")
options, args = parser.parse_args(argv)
log_utils.default_logging_config()
if len(args) > 1:
gitdir = args[1]
else:
gitdir = "."
from dulwich import porcelain
porcelain.daemon(gitdir, address=options.listen_address, port=options.port)
def main(argv=sys.argv):
"""Entry point for starting an HTTP git server."""
if len(argv) > 1:
gitdir = argv[1]
else:
gitdir = os.getcwd()
# TODO: allow serving on other addresses/ports via command-line flag
listen_addr=''
port = 8000
log_utils.default_logging_config()
backend = DictBackend({'/': Repo(gitdir)})
app = HTTPGitApplication(backend)
server = make_server(listen_addr, port, app,
handler_class=HTTPGitRequestHandler)
logger.info('Listening for HTTP connections on %s:%d', listen_addr,
port)
server.serve_forever()
def main(argv=sys.argv):
"""Entry point for starting an HTTP git server."""
if len(argv) > 1:
gitdir = argv[1]
else:
gitdir = os.getcwd()
# TODO: allow serving on other addresses/ports via command-line flag
listen_addr=''
port = 8000
log_utils.default_logging_config()
backend = DictBackend({'/': Repo(gitdir)})
app = make_wsgi_chain(backend)
server = make_server(listen_addr, port, app,
handler_class=HTTPGitRequestHandler)
logger.info('Listening for HTTP connections on %s:%d', listen_addr,
port)
server.serve_forever()
def main(argv=sys.argv):
"""Entry point for starting a TCP git server."""
import optparse
parser = optparse.OptionParser()
parser.add_option("-l", "--listen_address", dest="listen_address",
default="localhost",
help="Binding IP address.")
parser.add_option("-p", "--port", dest="port", type=int,
default=TCP_GIT_PORT,
help="Binding TCP port.")
options, args = parser.parse_args(argv)
log_utils.default_logging_config()
if len(args) > 1:
gitdir = args[1]
else:
gitdir = '.'
from dulwich import porcelain
porcelain.daemon(gitdir, address=options.listen_address,
port=options.port)
def main(argv=sys.argv):
"""Entry point for starting a TCP git server."""
import optparse
parser = optparse.OptionParser()
parser.add_option("-b", "--backend", dest="backend",
help="Select backend to use.",
choices=["file"], default="file")
options, args = parser.parse_args(argv)
log_utils.default_logging_config()
if options.backend == "file":
if len(argv) > 1:
gitdir = args[1]
else:
gitdir = '.'
backend = DictBackend({'/': Repo(gitdir)})
else:
raise Exception("No such backend %s." % backend)
server = TCPGitServer(backend, 'localhost')
server.serve_forever()
def main(argv=sys.argv):
"""Entry point for starting a TCP git server."""
import optparse
parser = optparse.OptionParser()
parser.add_option("-b", "--backend", dest="backend",
help="Select backend to use.",
choices=["file"], default="file")
options, args = parser.parse_args(argv)
log_utils.default_logging_config()
if options.backend == "file":
if len(argv) > 1:
gitdir = args[1]
else:
gitdir = '.'
backend = DictBackend({'/': Repo(gitdir)})
else:
raise Exception("No such backend %s." % backend)
server = TCPGitServer(backend, 'localhost')
server.serve_forever()
def main(argv=sys.argv):
"""Entry point for starting a TCP git server."""
import optparse
parser = optparse.OptionParser()
parser.add_option("-l", "--listen_address", dest="listen_address",
default="localhost",
help="Binding IP address.")
parser.add_option("-p", "--port", dest="port", type=int,
default=TCP_GIT_PORT,
help="Binding TCP port.")
options, args = parser.parse_args(argv)
log_utils.default_logging_config()
if len(args) > 1:
gitdir = args[1]
else:
gitdir = '.'
# TODO(jelmer): Support git-daemon-export-ok and --export-all.
backend = FileSystemBackend(gitdir)
server = TCPGitServer(backend, options.listen_address, options.port)
server.serve_forever()
def make_app(global_config, **local_conf):
"""Factory function for a Paster WSGI app
:param append_git: each served git repo have .git appended to its
served URL.
:param serve_dirs: list of parent paths to check for sub-directories
to serve.
:returns: An instance of dulwich.web.HTTPGitApplication
Two options to serve: serve_dirs and individual URL path to operating
system path mappings.
Example::
File-system layout:
+-/var/lib/git
|-foo
|-bar
`-baz
+-/home/git
|-bing
`-bang
paster.ini:
[app:main]
use = egg:dulwich
append_git = True
serve_dirs =
/var/lib/git
/home/git
blerg = /home/dannyboy/src/blerg
Will result in the following being served::
/foo.git => /var/lib/git/foo
/bar.git => /var/lib/git/bar
/baz.git => /var/lib/git/baz
/bing.git => /home/git/bing
/bang.git => /home/git/bang
/blerg.git => /home/dannyboy/src/blerg
NOTE: The last name definition wins. Whatever directory in serve_dirs is
last, or the last explicit mapping for the same name is what will
be mapped.
"""
from paste.deploy.converters import asbool
from paste.deploy.converters import aslist
repos = {}
append_git = asbool(local_conf.pop('append_git', False))
serve_dirs = aslist(local_conf.pop('serve_dirs', None))
log_utils.default_logging_config()
def add_repo(mapping, path, gitdir):
try:
mapping[path] = Repo(gitdir)
except NotGitRepository:
logger.error('Not a git repository, cannot serve: "%s".',
gitdir)
if not local_conf and not serve_dirs:
add_repo(repos, '/', os.getcwd())
else:
if serve_dirs:
for top_dir in serve_dirs:
if not os.path.isdir(top_dir):
logger.error('Not a directory, cannot serve: "%s".',
top_dir)
for d in os.listdir(top_dir):
repo_path = '/'.join(('', d))
gitdir = os.path.join(top_dir, d)
add_repo(repos, repo_path, gitdir)
for repo_name, gitdir in local_conf.items():
repo_path = '/'.join(('', repo_name))
add_repo(repos, repo_path, gitdir)
if not repos:
msg = 'No repositories to serve, check the ini file: "%s".'
logger.error(msg, global_config['__file__'])
raise IndexError(msg % global_config['__file__'])
if append_git:
new_repos = {}
for rpath, repo in repos.items():
if rpath.endswith('.git'):
# Don't be redundant...
new_repos[rpath] = repo
logger.debug('Not renaming, already ends in .git: "%s".',
rpath)
else:
new_repos['.'.join((rpath, 'git'))] = repo
backend = DictBackend(new_repos)
else:
backend = DictBackend(repos)
return HTTPGitApplication(backend)
