def handle(self, *args, **options): # quiet = options.get('quiet', False) # not used if not args: return try: ms = Milestone.objects.get(code=args[0]) except: raise CommandError("No milestone with code %s found" % args[0]) forest = ms.appver.trees_over_time.latest().tree.l10n.name.split('/') def resolve(path): return os.path.join(settings.REPOSITORY_BASE, *(forest + path.split('/'))) if ms.status == Milestone.SHIPPED: sos = ms.signoffs else: sos = accepted_signoffs(ms.appver) sos = dict(sos.values_list('locale__code', 'push_id')) tips = dict( Push.objects.filter(id__in=sos.values()).annotate( tip=Max('changesets__id')).values_list('id', 'tip')) revs = dict( Changeset.objects.filter(id__in=tips.values()).values_list( 'id', 'revision')) from mercurial import dispatch for loc in sorted(sos.keys()): repopath = resolve(loc) rev = revs[tips[sos[loc]]] dispatch.dispatch( dispatch.request(['update', '-R', repopath, '-r', rev]))
def handle(self, *args, **options): quiet = options.get('quiet', False) if not args: return try: ms = Milestone.objects.get(code=args[0]) except: raise CommandError, "No milestone with code %s found" % args[0] forest = ms.appver.tree.l10n.name.split('/') def resolve(path): return os.path.join(settings.REPOSITORY_BASE, *(forest + path.split('/'))) if ms.status == Milestone.SHIPPED: sos = ms.signoffs else: sos = accepted_signoffs(id=ms.appver_id) sos=dict(sos.values_list('locale__code', 'push_id')) tips = dict(Push.objects.filter(id__in=sos.values()).annotate(tip=Max('changesets__id')).values_list('id', 'tip')) revs = dict(Changeset.objects.filter(id__in=tips.values()).values_list('id','revision')) from mercurial import dispatch for loc in sorted(sos.keys()): repopath = resolve(loc) rev = revs[tips[sos[loc]]] dispatch.dispatch( dispatch.request(['update', '-R', repopath, '-r', rev]) )
def getattr(self, path, fh=None): if self.args.clone: dispatch(request(["--cwd", self.tmp, "pull", "-u"])) apath = os.path.join(self.tmp, path[1:]) st = os.lstat(apath) return dict((key, getattr(st, key)) for key in self.ATTRS)
def test_push_single_dir_renamed_branch(self, stupid=False): # Tests pulling and pushing with a renamed branch # Based on test_push_single_dir test_util.load_svndump_fixture(self.repo_path, 'branch_from_tag.svndump') cmd = ['clone', '--layout=single', '--branch=flaf'] if stupid: cmd.append('--stupid') cmd += [test_util.fileurl(self.repo_path), self.wc_path] dispatch.dispatch(cmd) def file_callback(repo, memctx, path): if path == 'adding_file': return context.memfilectx(path=path, data='foo', islink=False, isexec=False, copied=False) raise IOError(errno.EINVAL, 'Invalid operation: ' + path) ctx = context.memctx(self.repo, (self.repo['tip'].node(), node.nullid), 'automated test', ['adding_file'], file_callback, 'an_author', '2009-10-19 18:49:30 -0500', {'branch': 'default',}) self.repo.commitctx(ctx) hg.update(self.repo, self.repo['tip'].node()) self.pushrevisions() self.assertTrue('adding_file' in self.svnls('')) self.assertEquals(set(['flaf']), set(self.repo[i].branch() for i in self.repo))
def main(argv): log = repolib.get_logger('validate-login') user = argv[-1] path = parse_path() log.info("Validating login for %r on %r", user, path) if path: repo = repolib.Repository(path) repo.repo_path = os.getcwd() else: log.error("Invalid command") return 1 if not repo.exists: log.error("Repo %s does not exist", repo.full_path) return 1 try: repo.load_from_hgrc() except IOError: log.error("Could not read repo config") return 1 if not repo.can_be_read_by(user): log.error("You can not read this repository") return 1 os.environ['SSH_HG_USER'] = user os.environ['SSH_HG_REPO'] = repo.full_path log.info("All checks passed, serving.") dispatch.dispatch(['-R', path, 'serve', '--stdio'])
def rmdir(self, path): _path = path[1:] apath = os.path.join(self.tmp, _path) dpath = os.path.join(self.tmp, ".hgfs", _path) hpath = os.path.join(self.tmp, ".hgfs", _path + ".attr") try: status = os.rmdir(dpath) except: pass status = os.rmdir(apath) try: status = os.unlink(hpath) except: pass uid, gid, pid = fuse_get_context() username = pwd.getpwuid(uid)[0] dispatch( request(["--cwd", self.tmp, "commit", "-A", "-u", username, "-m", "hgfs[rmdir]: %s" % (_path), str(_path)]) ) if self.args.clone: dispatch(request(["--cwd", self.tmp, "push"])) return status
def symlink(self, target, source): _source = source[1:] _target = target[1:] asource = os.path.join(self.tmp, _source) atarget = os.path.join(self.tmp, _target) status = os.symlink(source, atarget) uid, gid, pid = fuse_get_context() username = pwd.getpwuid(uid)[0] dispatch( request( [ "--cwd", self.tmp, "commit", "-A", "-u", username, "-m", "hgfs[symlink]: %s -> %s" % (_target, source), str(source), str(_target), ] ) ) if self.args.clone: dispatch(request(["--cwd", self.tmp, "push"])) return status
def read(self, path, size, offset, fh): if self.args.clone: dispatch(request(["--cwd", self.tmp, "pull", "-u"])) os.lseek(fh, offset, os.SEEK_SET) data = os.read(fh, size) return data
def destroy(self, path): try: dispatch(request(["--cwd", self.tmp, "commit", "-A", "-u", "hgfs", "-m", "hgfs[cruft]"])) if self.args.clone: dispatch(request(["--cwd", self.tmp, "push"])) finally: if self.args.clone: shutil.rmtree(self.tmp)
def open(self, path, flags): if self.args.clone: dispatch(request(["--cwd", self.tmp, "pull", "-u"])) self.__load_attributes() _path = path[1:] apath = os.path.join(self.tmp, _path) return os.open(apath, flags)
def main(): cwd = os.getcwd() readonly = False args = sys.argv[1:] while len(args): if args[0] == '--read-only': readonly = True args.pop(0) else: break allowed_paths = [ os.path.normpath(os.path.join(cwd, os.path.expanduser(path))) for path in args ] orig_cmd = os.getenv('SSH_ORIGINAL_COMMAND', '?') try: cmdargv = shlex.split(orig_cmd) except ValueError as e: sys.stderr.write('Illegal command "%s": %s\n' % (orig_cmd, e)) sys.exit(255) if cmdargv[:2] == ['hg', '-R'] and cmdargv[3:] == ['serve', '--stdio']: path = cmdargv[2] repo = os.path.normpath(os.path.join(cwd, os.path.expanduser(path))) if next( (True for patt in allowed_paths if fnmatch.fnmatch(repo, patt)), False) and os.path.isdir(os.path.join(repo, '.hg')): cmd = ['-R', repo, 'serve', '--stdio'] req = dispatch.request(cmd) if readonly: if not req.ui: req.ui = uimod.ui.load() req.ui.setconfig('hooks', 'pretxnopen.hg-ssh', 'python:__main__.rejectpush', 'hg-ssh') req.ui.setconfig('hooks', 'prepushkey.hg-ssh', 'python:__main__.rejectpush', 'hg-ssh') dispatch.dispatch(req) else: sys.stderr.write('Illegal repository "%s"\n' % repo) sys.exit(255) elif len(cmdargv) == 3 and cmdargv[:2] == ['hg', 'init']: path = cmdargv[2] repo = os.path.normpath(os.path.join(cwd, os.path.expanduser(path))) if not readonly and next( (True for patt in allowed_paths if fnmatch.fnmatch(repo, patt)), False): cmd = ['init', repo] req = dispatch.request(cmd) dispatch.dispatch(req) else: sys.stderr.write('Permission denied "%s"\n' % repo) sys.exit(255) else: sys.stderr.write('Illegal command "%s"\n' % orig_cmd) sys.exit(255)
def handle(self, *args, **options): rebase = options.get('rebase', False) update = options.get('update', False) all = options.get('all', False) if rebase: pull_args = ['--rebase'] elif update: pull_args = ['-u'] else: pull_args = [] from life.models import Repository, Changeset from mercurial import dispatch import os.path from django.conf import settings def resolve(path): return os.path.join(settings.REPOSITORY_BASE, *path.split('/')) # check for last push helper file if not all and os.path.isfile(resolve('.latest_cs')): latest_cs = int(open(resolve('.latest_cs')).read()) repos = (Repository.objects .filter(changesets__id__gt=latest_cs) .distinct()) else: repos = Repository.objects.all() latest_cs = Changeset.objects.order_by('-pk')[0].id for name, url in repos.values_list('name', 'url'): repopath = str(resolve(name)) if not os.path.isdir(os.path.join(repopath, '.hg')): # new repo, need to clone if os.path.isdir(repopath): self.stdout.write(("\n\nCannot clone %s, " "existing directory in the way\n\n") % name) continue _parent = os.path.dirname(repopath) if not os.path.isdir(_parent): try: os.makedirs(_parent) except Exception as e: self.stdout.write( ("\n\nFailed to prepare for clone, %s\n\n" % str(e)) ) continue dispatch.dispatch( dispatch.request(['clone', str(url), repopath]) ) else: dispatch.dispatch( dispatch.request(['pull', '-R', repopath] + pull_args) ) open(resolve('.latest_cs'), 'w').write('%i\n' % latest_cs)
def readdir(self, path, fh): if self.args.clone: dispatch(request(["--cwd", self.tmp, "pull", "-u"])) apath = os.path.join(self.tmp, path[1:]) paths = os.listdir(apath) clean = [] for path in paths: if path != ".hg" and path != ".hgfs": clean.append(path) return [".", ".."] + clean
def rename(self, old, new): _old = old[1:] _new = new[1:] uid, gid, pid = fuse_get_context() username = pwd.getpwuid(uid)[0] dispatch(request(["--cwd", self.tmp, "mv", _old, _new])) dispatch( request( ["--cwd", self.tmp, "mv", os.path.join(".hgfs", _old + ".attr"), os.path.join(".hgfs", _new + ".attr")] ) ) dispatch( request( [ "--cwd", self.tmp, "commit", "-u", username, "-m", "hgfs[rename]: %s -> %s" % (_old, _new), str(_old), str(_new), ] ) ) if self.args.clone: dispatch(request(["--cwd", self.tmp, "push"])) return 0
def main(): user = sys.argv[1] conf = sys.argv[2] # get original ssh command orig_cmd = os.getenv('SSH_ORIGINAL_COMMAND', '?') try: cmdargv = shlex.split(orig_cmd) except ValueError as e: sys.stderr.write("Illegal command \"%s\": %s\n" % (orig_cmd, e)) sys.exit(1) if cmdargv[:2] != ['hg', '-R'] or cmdargv[3:] != ['serve', '--stdio']: sys.stderr.write("Illegal command \"%s\"\n" % orig_cmd) sys.exit(1) repo = cmdargv[2].replace(os.sep, '', 1) perm = get_permissions(repo, conf) if not len(perm): sys.stderr.write("Repository \"%s\" not found\n" % repo) sys.exit(1) if 'location' not in perm: sys.stderr.write("Repository \"%s\" has no location\n" % repo) sys.exit(1) path = os.path.normpath(os.path.join( os.getcwd(), os.path.expanduser(perm['location']) )) if (user not in perm) or (perm[user] not in ['read', 'write']): sys.stderr.write("Access denied to \"%s\"\n" % repo) sys.exit(1) cmd = ['-R', path, 'serve', '--stdio'] if perm[user] == 'read': cmd += [ '--config', 'hooks.prechangegroup.hg-ssh=python:__main__.reject_push', '--config', 'hooks.prepushkey.hg-ssh=python:__main__.reject_push' ] dispatch.dispatch(dispatch.request(cmd))
def hg_serve(user, options, args): if not options.repository: raise subssh.InvalidArguments("Repository is missing") if not options.stdio: raise subssh.InvalidArguments("'--stdio' is missing") if not valid_repo.match(options.repository): subssh.errln("Illegal repository path '%s'" % options.repository) return 1 repo_name = os.path.basename(options.repository.lstrip("/")) # Transform virtual root real_repository_path = os.path.join(config.REPOSITORIES, repo_name) repo = Mercurial(real_repository_path, subssh.config.ADMIN) if not repo.has_permissions(user.username, "r"): raise InvalidPermissions("%s has no read permissions to %s" %(user.username, options.repository)) from mercurial.dispatch import dispatch return dispatch(['-R', repo.repo_path, 'serve', '--stdio'])
def get_data(self, args): """ Return the data generated from mercurial. """ fout = StringIO.StringIO() ferr = StringIO.StringIO() dispatch.dispatch(dispatch.request(args, None, None, None, fout, ferr)) fout_value = fout.getvalue() ferr_value = ferr.getvalue() fout.close() ferr.close() return {"fout": base64.b64encode(fout_value), "ferr": base64.b64encode(ferr_value)}
def _init(repo_root, user_name, args): # get repo path repo_path = None for i in range(len(args)): if args[i] == 'init': repo_path = args[i+1] # validate repo path if repo_path is None: raise RuntimeError('Invalid repository path') # get full repo path full_repo_path = os.path.join(repo_root, repo_path) # replace old repo path for i in range(len(args)): if args[i] == repo_path: args[i] = full_repo_path if dispatch(args) is None: with open(os.path.join(full_repo_path, '.hg', 'hgrc'), 'w') as fp: fp.write('''\ [web] contact = %(user)s description = %(path)s ''' % dict(user = user_name, path = repo_path)) print >> sys.stderr, 'Created: %r' % full_repo_path else: raise RuntimeError('Failed to create: %r' % full_repo_path)
def write(self, path, data, offset, fh): _path = path[1:] apath = os.path.join(self.tmp, _path) os.lseek(fh, offset, os.SEEK_SET) os.write(fh, data) uid, gid, pid = fuse_get_context() username = pwd.getpwuid(uid)[0] dispatch( request(["--cwd", self.tmp, "commit", "-A", "-u", username, "-m", "hgfs[write]: %s" % (_path), str(_path)]) ) if self.args.clone: dispatch(request(["--cwd", self.tmp, "push"])) return len(data)
def testdispatch(cmd): """Simple wrapper around dispatch.dispatch() Prints command and result value, but does not handle quoting. """ print "running: %s" % (cmd,) result = dispatch.dispatch(cmd.split()) print "result: %r" % (result,)
def testdispatch(cmd): """Simple wrapper around dispatch.dispatch() Prints command and result value, but does not handle quoting. """ print "running: %s" % (cmd, ) result = dispatch.dispatch(cmd.split()) print "result: %r" % (result, )
def load_fixture_and_fetch( fixture_name, repo_path, wc_path, stupid=False, subdir="", noupdate=True, layout="auto", startrev=0, externals=None ): load_svndump_fixture(repo_path, fixture_name) if subdir: repo_path += "/" + subdir cmd = ["clone", "--layout=%s" % layout, "--startrev=%s" % startrev, fileurl(repo_path), wc_path] if stupid: cmd.append("--stupid") if noupdate: cmd.append("--noupdate") if externals: cmd[:0] = ["--config", "hgsubversion.externals=%s" % externals] dispatch.dispatch(cmd) return hg.repository(testui(), wc_path)
def testdispatch(cmd): """Simple wrapper around dispatch.dispatch() Prints command and result value, but does not handle quoting. """ ui = uimod.ui.load() ui.status(b"running: %s\n" % cmd) req = dispatch.request(cmd.split(), ui) result = dispatch.dispatch(req) ui.status(b"result: %r\n" % result)
def truncate(self, path, length, fh=None): _path = path[1:] apath = os.path.join(self.tmp, _path) if fh == None: with open(apath, "wb") as f: pass else: os.ftruncate(fh, length) uid, gid, pid = fuse_get_context() username = pwd.getpwuid(uid)[0] dispatch( request( ["--cwd", self.tmp, "commit", "-A", "-u", username, "-m", "hgfs[truncate]: %s" % (_path), str(_path)] ) ) if self.args.clone: dispatch(request(["--cwd", self.tmp, "push"]))
def __init__(self, repo, mountpoint=".", args={}): self.log.setLevel(args.log) self.log.debug("repo: %s mountpoint: %s args: %s", repo, mountpoint, repr(args)) self.repo = repo self.mountpoint = os.path.abspath(mountpoint) self.args = args if not self.args.clone: self.repo = os.path.abspath(repo) self.log.debug("SELF: repo: %s mountpoint: %s args: %s", self.repo, self.mountpoint, repr(self.args)) if self.args.clone: self.tmp = os.path.abspath(tempfile.mkdtemp(prefix="hgfs-")) dispatch(request(["clone", self.repo, self.tmp])) else: self.tmp = self.repo self.log.debug("Tmp: %s", self.tmp) self.__load_attributes()
def load_fixture_and_fetch(fixture_name, repo_path, wc_path, stupid=False, subdir='', noupdate=True, layout='auto', startrev=0, externals=None): load_svndump_fixture(repo_path, fixture_name) if subdir: repo_path += '/' + subdir cmd = [ 'clone', '--layout=%s' % layout, '--startrev=%s' % startrev, fileurl(repo_path), wc_path, ] if stupid: cmd.append('--stupid') if noupdate: cmd.append('--noupdate') if externals: cmd[:0] = ['--config', 'hgsubversion.externals=%s' % externals] dispatch.dispatch(cmd) return hg.repository(testui(), wc_path)
def _serve(repo_root, user_name, args): # get repo path repo_path = None for i in range(len(args)): if args[i] == '-R': repo_path = args[i+1] # validate repo path if repo_path is None: raise RuntimeError('Invalid repository path') # get full repo path full_repo_path = os.path.join(repo_root, repo_path) # replace old repo path for i in range(len(args)): if args[i] == repo_path: args[i] = full_repo_path return dispatch(args)
def freenetclone(orig, *args, **opts): def parsepushargs(ui, repo, path=None): return ui, repo, path def isfreenetpath(path): try: if path.startswith("freenet:") or path.startswith("USK@"): return True except AttributeError: return False return False ui, source, dest = parsepushargs(*args) # only act differently, if dest or source is an infocalypse repo. if not isfreenetpath(source) and not isfreenetpath(dest): return orig(*args, **opts) if not dest: if not isfreenetpath(source): dest = hg.defaultdest(source) else: # this is a freenet key. It has a /# at the end and # could contain .R1 or .R0 as pure technical identifiers # which we do not need in the local name. segments = source.split("/") pathindex = -2 try: int(segments[-1]) except ValueError: # no number revision pathindex = -1 dest = segments[pathindex] if dest.endswith(".R1") or dest.endswith(".R0"): dest = dest[:-3] # TODO: source holds the "repo" argument, but the naming is confusing in # the context of freenetpathtouri(). # check whether to create, pull or copy pulluri, pushuri = None, None if isfreenetpath(source): pulluri = parse_repo_path( freenetpathtouri(ui, source, "pull", None, opts.get('truster'))) if isfreenetpath(dest): pushuri = parse_repo_path(freenetpathtouri(ui, dest, "clone-push", fcphost=opts['fcphost'], fcpport=opts['fcpport']), assume_redundancy=True) # decide which infocalypse command to use. if pulluri and pushuri: action = "copy" elif pulluri: action = "pull" elif pushuri: action = "create" else: raise util.Abort( """Can't clone without source and target. This message should not be reached. If you see it, this is a bug.""" ) if action == "copy": raise util.Abort( """Cloning without intermediate local repo not yet supported in the simplified commands. Use fn-copy directly.""" ) if action == "create": # if the pushuri is the short form (USK@/name/#), generate the key. if pushuri.startswith("USK@/"): ui.status( "creating a new key for the repo. To use your default key, call fn-create.\n" ) from sitecmds import genkeypair fcphost, fcpport = opts["fcphost"], opts["fcpport"] if not fcphost: fcphost = DEFAULT_FCP_HOST if not fcpport: fcpport = DEFAULT_FCP_PORT # use redundant keys by default, except if explicitely requested otherwise. namepart = pushuri[5:] namepart = fixnamepart(namepart) insert, request = genkeypair(fcphost, fcpport) pushuri = "USK" + insert[3:] + namepart elif pushuri.endswith("/0"): # initial create, catch the no-.R1 error pass # this rewriting is dangerous here since it could make it # impossible to update old repos when they drop # out. Leaving it commented out for now. TODO: Always # treat a name without .R0 as requesting redundancy *in. # the backend*. Keep it as /name/#, but add /name.Rn/0 # backup repos. Needs going into the backend. #namepart = pushuri.split("/")[-2] + "/0" #namepartpos = -len(namepart) #namepart2 = fixnamepart(namepart) # if namepart2 != namepart: # ui.status("changed the repo name to " + namepart2 + " to have more redundancy and longer lifetime. This is a small tweak on infocalypse to avoid the frequent error of forgetting to add .R1 to the name. If you really want no additional redundancy for your repo, use NAME.R0 or call hg fn-create directly.\n") #pushuri = pushuri[:namepartpos] + namepart opts["uri"] = pushuri repo = hg.repository(ui, ui.expandpath(source)) # TODO: A local identity is looked up for the push URI, # but not returned, yet it is required to update configuration. # Expecting dest to be something like freenet://name@key/reponame local_identifier = strip_protocol(dest).split('/')[0] from wot_id import Local_WoT_ID from wot import get_fcpopts local_identity = Local_WoT_ID( local_identifier, get_fcpopts(fcphost=opts["fcphost"], fcpport=opts["fcpport"])) infocalypse_create(ui, repo, local_identity, **opts) # TODO: Function for adding paths? It's currently here, for pull, # and in WoT pull URI resolution. with repo.opener("hgrc", "a", text=True) as f: f.write("""[paths] default-push = freenet:{0} """.format(pushuri)) if action == "pull": if os.path.exists(dest): raise util.Abort(_("destination " + dest + " already exists.")) # create the repo req = dispatch.request(["init", dest], ui=ui) dispatch.dispatch(req) # pull the data from freenet origdest = ui.expandpath(dest) dest, branch = hg.parseurl(origdest) destrepo = hg.repository(ui, dest) infocalypse_pull(ui, destrepo, aggressive=True, hash=None, uri=pulluri, **opts) # store the request uri for future updates _hgrc_template = """[paths] default = freenet://{pulluri} [ui] username = anonymous [alias] clt = commit ci = !$HG clt --date "$(date -u "+%Y-%m-%d %H:%M:%S +0000")" "$@" commit = !$HG clt --date "$(date -u "+%Y-%m-%d %H:%M:%S +0000")" "$@" """ # alternative: every commit is done at 09:42:30 (might be # confusing but should be safest): date -u "+%Y-%m-%d 09:42:30 +0000 # second alternative: commit done at local time but with # timezone +0000 (could be correlated against forum entries # and such to find the real timezone): Leave out the -u with destrepo.opener("hgrc", "a", text=True) as f: f.write(_hgrc_template.format(pulluri=pulluri)) ui.warn("As basic protection, infocalypse automatically \n" " set the username 'anonymous' for commits in this repo, \n" " changed the commands `commit` and `ci` to fake UTC time \n" " and added `clt` which commits in the local timezone. \n" " To change this, edit " + str(os.path.join(destrepo.root, ".hg", "hgrc")) + "\n") # and update the repo return hg.update(destrepo, None)
def main(): cwd = os.getcwd() user = sys.argv[1] conf = sys.argv[2] # Get the original SSH Command sent through. The repo should be the item after the connect string orig_cmd = os.getenv('SSH_ORIGINAL_COMMAND', '?') try: cmdargv = shlex.split(orig_cmd) # Changed to "as" here for Python 3.3 compatibility except ValueError as e: sys.stderr.write('Illegal command "%s": %s\n' % (orig_cmd, e)) sys.exit(255) if cmdargv[:2] == ['hg', '-R'] and cmdargv[3:] == ['serve', '--stdio']: try: # Now we need to extract the repository name (what is in the conf file) repository = cmdargv[2].replace(os.sep, '', 1) # Get the repository and users from the config file (or get a blank {}) perms = get_permission(repository, conf) # If the returned dict is empty, then exit this process. This means no section with # the named repository exist! if not len(perms): sys.stderr.write('No repository found for "%s"\n' % repository) sys.exit(255) # This is the reason we are using a try in case this key does not exist. # 'location' param under repository section contains the relative or absolute path # to the repository on the file system from the current working # directory which can be changed in the authorized_keys path = perms['location'] # Get the path of the repository to be used with hg commands below. # This is the translation between the section name in the conf file and # the location param that points to the actual directory on the file system # By default, this uses cwd (Current working directory) and can be changed in the # authorized_keys file in the command section by using 'cd /path/to/start/from && ' # as the first part of the command string before calling this script. repo = os.path.normpath(os.path.join(cwd, os.path.expanduser(path))) except KeyError: sys.stderr.write('Invalid Repository "%s"\n' % repository) sys.exit(255) # We will try and get the username out of the config, if it is not present, we exit! # We will also check to make sure the access is set to read or write. If Not, goodbye! try: access = perms[user] except: sys.stderr.write('Illegal Repository "%s"\n' % repo) sys.exit(255) # If the user does not have read or write (write implies read) we exit. if access not in ['read', 'write']: sys.stderr.write('Access denied to "%s"\n' % repository) sys.exit(255) cmd = ['-R', repo, 'serve', '--stdio'] if access == "read": cmd += [ '--config', 'hooks.prechangegroup.hg-ssh=python:__main__.rejectpush', '--config', 'hooks.prepushkey.hg-ssh=python:__main__.rejectpush' ] dispatch.dispatch(dispatch.request(cmd)) else: sys.stderr.write('Illegal command "%s"\n' % orig_cmd) sys.exit(255)
def readlink(self, path): if self.args.clone: dispatch(request(["--cwd", self.tmp, "pull", "-u"])) apath = os.path.join(self.tmp, path[1:]) return os.readlink(apath)
def dispatch(cmd): assert '--quiet' in cmd cmd = getattr(dispatchmod, 'request', lambda x: x)(cmd) return dispatchmod.dispatch(cmd)
def dispatch(*args): return _dispatch.dispatch(_dispatch.request(*args))
from mercurial.dispatch import dispatch args = [’clone’,’http://petsc.cs.iit.edu/petsc/tutorials/vecfem] dispatch(args)
def dispatch(*args): return _dispatch.dispatch(*args)
apath = os.path.join(self.tmp, _path) st = os.stat(apath) attributes = dict((key, getattr(st, key)) for key in self.ATTRS) uid, gid, pid = fuse_get_context() username = pwd.getpwuid(uid)[0] attributes[".hgfs"] = {"pw_uid": uid, "pw_name": username, "gr_gid": gid, "gr_name": grp.getgrgid(gid)[0]} modpath = os.path.join(self.tmp, ".hgfs", _path + ".attr") with open(modpath, "wb+") as f: f.write(json.dumps(attributes, sort_keys=True, indent=2)) ahgfs = os.path.join(self.tmp, ".hgfs") dispatch(request(["--cwd", self.tmp, "commit", "-A", "-u", username, "-m", msg, ".hgfs", str(_path)])) if self.args.clone: dispatch(request(["--cwd", self.tmp, "push"])) def access(self, path, mode): _path = path[1:] apath = os.path.join(self.tmp, _path) if not os.access(apath, mode): raise FuseOSError(EACCES) def chmod(self, path, mode): _path = path[1:] apath = os.path.join(self.tmp, _path) status = os.chmod(apath, mode)
def runcmd(): dispatch.dispatch(dispatch.request(['version', '-q'], ui_))
def hg_dispatch(cmdargv): logger.debug(_("Using in-process Mercurial dispatch")) return dispatch.dispatch(dispatch.request(cmdargv))
def dispatch(cmd): cmd = getattr(dispatchmod, 'request', lambda x: x)(cmd) return dispatchmod.dispatch(cmd)
sys.stderr.write('Illegal command "%s": %s\n' % (orig_cmd, e)) sys.exit(255) if cmdargv[:2] == ['hg', '-R'] and cmdargv[3:] == ['serve', '--stdio']: path = cmdargv[2] repo = os.path.normpath(os.path.join(cwd, os.path.expanduser(path))) if path in perms: cmd = ['-R', repo, 'serve', '--stdio'] if perms[path] == "read": cmd += [ '--config', 'hooks.prechangegroup.hg-ssh=python:__main__.rejectpush', '--config', 'hooks.prepushkey.hg-ssh=python:__main__.rejectpush' ] dispatch.dispatch(dispatch.request(cmd)) else: sys.stderr.write('Illegal repository "%s"\n' % repo) sys.exit(255) else: sys.stderr.write('Illegal command "%s"\n' % orig_cmd) sys.exit(255) def rejectpush(ui, **kwargs): ui.warn("Permission denied\n") # mercurial hooks use unix process conventions for hook return values # so a truthy return means failure return True if __name__ == '__main__': main()