def update_gist(user, gist, data, summary, message=code.GIST_UPDATE_COMMIT):
try:
update_data = False
if summary != gist.summary:
gist.summary = summary
update_data = True
if data:
jagare = get_jagare(gist.id, gist.parent)
error, ret = jagare.update_file(gist.get_real_path(), data, user,
message)
if error:
db.session.rollback()
return None, error
logger.info(ret)
if ret:
from actions.gists import after_update_gist
gist.update = datetime.datetime.now()
update_data = True
after_update_gist(user, gist, asynchronous=True)
if update_data:
db.session.add(gist)
db.session.commit()
clear_gist_cache(gist)
return gist, None
except Exception, e:
db.session.rollback()
logger.exception(e)
return None, code.UNHANDLE_EXCEPTION
def edit(self,
organization,
repo,
team,
version=None,
path=None,
error_message=None):
watcher = get_repo_watcher(g.current_user.id, repo.id)
jagare = get_jagare(repo.id, repo.parent)
tname = team.name if team else None
content, content_type, _ = format_content(jagare,
repo,
path,
version=version,
render=False)
return self.render_template(
repo=repo, \
organization=organization, \
file_path=path, \
watcher=watcher, \
content=content, \
content_type=content_type, \
branches=get_branches(repo, jagare), \
version=version, \
path = render_path(
path, version, organization.git, \
tname, repo.name
), \
error_message=error_message, \
)
def update_repo(organization, repo, params):
try:
team = params.pop('team')
name = params.get('name', None)
default = params.get('default', None)
old_path = None
if default:
jagare = get_jagare(repo.id, repo.parent)
error, message = jagare.set_default_branch(repo.get_real_path(),
default)
if error:
return message
repo.default = default
if name:
old_path = repo.path
repo.name = name
repo.path = '%s.git' % name if not team else '%s/%s.git' % (
team.name, name)
if params:
db.session.add(repo)
db.session.commit()
clear_repo_cache(repo, organization, old_path=old_path)
return None
except sqlalchemy.exc.IntegrityError, e:
db.session.rollback()
if 'Duplicate entry' in e.message:
return code.REPOS_PATH_EXISTS
logger.exception(e)
return code.UNHANDLE_EXCEPTION
def get(self, organization, member, repo, admin, team, team_member,
version, path):
watcher = get_repo_watcher(g.current_user.id, repo.id)
jagare = get_jagare(repo.id, repo.parent)
tname = team.name if team else None
content, content_type, content_length = format_content(jagare,
repo,
path,
version=version)
return self.render_template(
member=member, repo=repo, \
organization=organization, \
watcher=watcher, file_path=path, \
branches=get_branches(repo, jagare), \
content=content, \
content_length=content_length, \
content_type=content_type, \
admin=admin, team=team, team_member=team_member, \
version=version, \
path=render_path(
path, version, organization.git, tname, repo.name
)
)
def get(self, organization, member, repo, admin, team, team_member):
jagare = get_jagare(repo.id, repo.parent)
branches = jagare.get_branches_names(repo.get_real_path())
return self.render_template(
branches_switch=branches, \
member=member, repo=repo, \
organization=organization, \
admin=admin, team=team, team_member=team_member, \
)
def check_obj_type(repo, path, version, t):
jagare = get_jagare(repo.id, repo.parent)
error, r = jagare.cat_file(repo.get_real_path(),
path=path,
version=version,
only_type=1)
if error or r.json()['data']['type'] != t:
return False
return True
def get(self, organization, member, gist, path):
jagare = get_jagare(gist.id, gist.parent)
error, res = jagare.cat_file(gist.get_real_path(), path)
if error:
raise abort(error)
resp = Response(stream_with_context(res))
resp.headers['X-Accel-Buffering'] = 'no'
resp.headers['Cache-Control'] = 'no-cache'
resp.headers['Content-Type'] = res.headers.get(
'content-type', 'application/octet-stream')
return resp
def get(self, organization, member, gist):
jagare = get_jagare(gist.id, gist.parent)
error, tree = jagare.ls_tree(gist.get_real_path())
if not error:
tree, meta = tree['content'], tree['meta']
tree = render_tree(jagare, tree, gist, organization, False)
return self.render_template(
organization=organization, \
member=member, \
error=error, \
tree=tree, \
gist=gist, \
)
def post(self, organization, member, gist):
summary = request.form.get('summary')
filenames = request.form.getlist('filename')
codes = request.form.getlist('code')
data = {}
if len(filenames) != len(codes):
raise abort(400)
for filename, content in zip(filenames, codes):
if not filename and not content:
continue
if not filename or not content:
return self.render_template(
organization=organization, \
member=member, \
error=code.GIST_WITHOUT_FILENAME if not filename else code.GIST_WITHOUT_CONTENT, \
tree=self.gen_tree(filenames, codes), \
gist=gist,
)
if data.get(filename):
return self.render_template(
organization=organization, \
member=member, \
error=code.GIST_FILENAME_EXISTS, \
tree=self.gen_tree(filenames, codes), \
gist=gist,
)
data[filename] = content
jagare = get_jagare(gist.id, gist.parent)
error, tree = jagare.ls_tree(gist.get_real_path())
if error:
return self.render_template(
organization=organization, \
member=member, \
error=code.REPOS_LS_TREE_FAILED, \
tree=self.gen_tree(filenames, codes), \
gist=gist,
)
data = self.diff(tree, data)
_, error = update_gist(g.current_user, gist, data, summary)
if error:
return self.render_template(
organization=organization, \
member=member, \
error=code.GIST_UPDATE_FAILED, \
tree=self.gen_tree(filenames, codes), \
gist=gist,
)
return redirect(gist.meta.view)
def get(self,
organization,
member,
repo,
admin,
team,
team_member,
version=None,
path=None):
version = version or repo.default
file_path = path
watcher = get_repo_watcher(g.current_user.id, repo.id)
jagare = get_jagare(repo.id, repo.parent)
tname = team.name if team else None
if not check_obj_type(repo, path, version, 'tree'):
raise abort(403)
error, tree = jagare.ls_tree(repo.get_real_path(),
path=path,
version=version)
readme = None
commit = None
if not error:
tree, meta = tree['content'], tree['meta']
readme, tree = self.render_tree(
jagare, \
repo, organization, \
tree, version, team, \
)
path = render_path(
path, version, organization.git, \
tname, repo.name
)
commit = self.get_commit_user(meta)
return self.render_template(
member=member, repo=repo, \
organization=organization, \
watcher=watcher, file_path=file_path, \
branches=get_branches(repo, jagare), \
tree=tree, error=error, \
readme=readme, \
version=version, \
admin=admin, team=team, team_member=team_member, \
path=path, commit=commit, \
)
def get(self, organization, member, repo, admin, team, team_member,
version):
jagare = get_jagare(repo.id, repo.parent)
error, commits = jagare.get_log(
repo.get_real_path(), \
size=1, start=version, \
)
if not commits:
raise abort(404)
commit = commits[0]
render_commit(commit, organization, repo)
commit['diffs'] = split_diff(commit['diff'])
return self.render_template(
member=member, repo=repo, \
organization=organization, \
admin=admin, team=team, team_member=team_member, \
commit=commit, \
)
def get(self,
organization,
member,
repo,
admin,
team,
team_member,
version=None,
path=None):
page = request.args.get('p', 1)
try:
page = int(page)
except ValueError:
raise abort(403)
version = version or repo.default
jagare = get_jagare(repo.id, repo.parent)
error, commits = jagare.get_log(
repo.get_real_path(), page=page, \
size=config.COMMITS_PER_PAGE, shortstat=1, \
start=version, path=path, \
)
if not commits:
raise abort(404)
list_page = render_commits_page(repo, page, path)
commits = self.render_commits(jagare,
organization,
repo,
commits,
list_page,
path=path)
return self.render_template(
member=member, repo=repo, \
organization=organization, \
branches=get_branches(repo, jagare), \
error=error, \
version=version, \
admin=admin, team=team, team_member=team_member, \
commits=commits, \
path=path, \
list_page=list_page, \
)
def get(self, organization, member, gist, version='master'):
jagare = get_jagare(gist.id, gist.parent)
error, tree = jagare.ls_tree(gist.get_real_path(), version=version)
if not error:
tree, meta = tree['content'], tree['meta']
tree = render_tree(jagare,
tree,
gist,
organization,
version=version)
watcher = get_gist_watcher(g.current_user.id, gist.id)
return self.render_template(
organization=organization, \
member=member, \
error=error, \
tree=tree, \
gist=gist, \
watcher=watcher, \
)
def get(self, organization, member, gist):
page = request.args.get('p', 1)
try:
page = int(page)
except ValueError:
raise abort(403)
jagare = get_jagare(gist.id, gist.parent)
error, revisions = jagare.get_log(gist.get_real_path(), page=page, size=config.REVISIONS_PER_PAGE)
if not revisions:
raise abort(404)
list_page = render_revisions_page(gist, page)
revisions = self.render_revisions(organization, gist, revisions, list_page)
return self.render_template(
organization=organization, \
member=member, \
error=error, \
revisions=revisions, \
gist=gist, \
list_page=list_page, \
)
def update_file(organization, user, repo, data, version, message):
jagare = get_jagare(repo.id, repo.parent)
error, ret = jagare.update_file(
repo.get_real_path(), \
data, user, \
message=message, \
branch=version, \
parent=version, \
)
if error:
logger.info(ret)
return error
from actions.repos import after_push_repo
repo.update = datetime.datetime.now()
db.session.add(repo)
db.session.commit()
clear_repo_cache(repo, organization)
after_push_repo(user,
repo,
start='refs/heads/%s' % version,
asynchronous=True)
def after_push_repo(user, repo, start='refs/heads/master', asynchronous=False):
refs_keys = REFS_KEYS.format(rid=repo.id)
head_key = HEAD_COMMIT_KEY.format(rid=repo.id, start=start)
last_key = LAST_COMMIT_KEY.format(rid=repo.id, start=start)
head = rdb.get(head_key)
last = rdb.get(last_key)
# Get new commits from last commit
jagare = get_jagare(repo.id, repo.parent)
err, logs = jagare.get_log(repo.get_real_path(), start, head, shortstat=1) or \
jagare.get_log(repo.get_real_path(), start, last, shortstat=1) or \
jagare.get_log(repo.get_real_path(), start, None, shortstat=1)
if err:
logger.exception(err)
return
if not logs:
return
commit_time = time.mktime(repo.update.timetuple())
data = {
'type':'push', \
'repo_id': repo.id, \
'committer_id': user.id, \
'commits_num': len(logs), \
'commit_time': commit_time, \
'branch': start, \
}
data['data'] = logs[:PUSH_COMMITS_LIMIT]
rdb.set(head_key, logs[0]['sha'])
rdb.set(last_key, logs[-1]['sha'])
rdb.sadd(refs_keys, head_key)
rdb.sadd(refs_keys, last_key)
data = msgpack.dumps(data)
for activities in get_activities(repo=repo):
if not asynchronous:
activities.add(data, commit_time)
continue
t = threading.Thread(target=activities.add, args=(data, commit_time))
t.start()
def delete_gist(user, gist, organization):
try:
keys = []
db.session.delete(gist)
organization.gists = Organization.gists - 1
db.session.add(organization)
user_gist = get_user_gist(organization.id, user.id)
user_gist.count = UserGists.count - 1
db.session.add(user_gist)
watchers = get_gist_watchers(gist.id)
keys.append('gists:watchers:{gid}'.format(gid=gist.id))
for watcher in watchers:
db.session.delete(watcher)
keys.append('gists:watcher:{uid}:{gid}'.format(uid=watcher.uid,
gid=gist.id))
keys.append('user:watch:gists:{uid}:{oid}'.format(
uid=watcher.uid, oid=organization.id))
jagare = get_jagare(gist.id, gist.parent)
ret, error = jagare.delete(gist.get_real_path())
if not ret:
db.session.rollback()
return error
if gist.parent > 0:
parent_gist = get_gist(gist.parent)
parent_gist.forks = Gists.forks - 1
db.session.add(parent_gist)
db.session.commit()
clear_gist_cache(gist, organization)
if gist.parent > 0:
clear_gist_cache(parent_gist)
clear_explore_cache(gist, user, organization)
from actions.gists import after_delete_gist
after_delete_gist(gist, asynchronous=True)
backend.delete_many(*keys)
return None
except Exception, e:
db.session.rollback()
logger.exception(e)
return code.UNHANDLE_EXCEPTION
def after_update_gist(user, gist, asynchronous=False, method='update'):
head_key = HEAD_COMMIT_KEY.format(gid=gist.id)
last_key = LAST_COMMIT_KEY.format(gid=gist.id)
head = rdb.get(head_key)
last = rdb.get(last_key)
# Get new commits from last commit
jagare = get_jagare(gist.id, gist.parent)
err, logs = jagare.get_log(gist.get_real_path(), head, shortstat=1) or \
jagare.get_log(gist.get_real_path(), last, shortstat=1) or \
jagare.get_log(gist.get_real_path(), None, shortstat=1)
if err:
logger.exception(err)
return
if not logs:
return
commit_time = time.mktime(gist.update.timetuple())
data = {
'type':'gist', \
'method': method, \
'gist_id': gist.id, \
'committer_id': user.id, \
'commits_num': len(logs), \
'commit_time': commit_time, \
}
rdb.set(head_key, logs[0]['sha'])
rdb.set(last_key, logs[-1]['sha'])
data['data'] = logs
data = msgpack.dumps(data)
for activities in get_activities(gist=gist):
if not asynchronous:
activities.add(data, commit_time)
continue
t = threading.Thread(target=activities.add, args=(data, commit_time))
t.start()
def create_gist(organization,
user,
summary,
data={},
parent=None,
private=None,
watchers=0,
message=code.GIST_CREATE_COMMIT):
try:
gist = Gists(summary,
organization.id,
user.id,
parent=parent,
private=private,
watchers=watchers)
db.session.add(gist)
organization.gists = Organization.gists + 1
db.session.add(organization)
user_gist = get_user_gist(organization.id, user.id)
if not user_gist:
user_gist = UserGists(organization.id, user.id, 1)
else:
user_gist.count = UserGists.count + 1
db.session.add(user_gist)
db.session.flush()
gist.path = os.path.join('gist', '%s.git' % (private or gist.id))
watcher = GistWatchers(user.id, gist.id, organization.id)
db.session.add(watcher)
jagare = get_jagare(gist.id, parent.id if parent else 0)
if not parent:
# Deal with new gist
if not data:
db.session.rollback()
return None, code.GIST_WITHOUT_CONTENT
ret, error = jagare.init(gist.get_real_path())
if not ret:
db.session.rollback()
return None, error
error, ret = jagare.update_file(gist.get_real_path(), data, user,
message)
if error:
db.session.rollback()
return None, error
else:
ret, error = jagare.clone(gist.get_real_path(),
parent.get_real_path())
if error:
db.session.rollback()
return None, error
parent.forks = Gists.forks + 1
db.session.add(parent)
db.session.commit()
clear_gist_cache(gist, organization)
if parent:
clear_gist_cache(parent)
clear_user_gist_cache(user, organization)
clear_explore_cache(gist, user, organization)
clear_watcher_cache(user, gist, organization)
from actions.gists import after_update_gist
after_update_gist(user, gist, asynchronous=True, method='create')
return gist, None
except sqlalchemy.exc.IntegrityError, e:
db.session.rollback()
if 'Duplicate entry' in e.message:
return None, code.REPOS_PATH_EXISTS
logger.exception(e)
return None, code.UNHANDLE_EXCEPTION
def get_branches(repo, jagare=None):
if not jagare:
jagare = get_jagare(repo.id, repo.parent)
return jagare.get_branches_names(repo.get_real_path())
def create_repo(name,
path,
user,
organization,
team=None,
summary='',
parent=None,
default='master'):
try:
tid = team.id if team else 0
oid = organization.id
uid = user.id
repo = Repos(name,
path,
oid,
uid,
tid,
summary,
parent,
commiters=1,
watchers=1,
default=default)
db.session.add(repo)
organization.repos = Organization.repos + 1
db.session.add(organization)
if team:
team.repos = Team.repos + 1
db.session.add(team)
db.session.flush()
if not check_repos_limit(organization):
db.session.rollback()
return None, code.ORGANIZATION_REPOS_LIMIT
commiter = Commiters(user.id, repo.id)
db.session.add(commiter)
watcher = Watchers(user.id, repo.id, organization.id)
db.session.add(watcher)
jagare = get_jagare(repo.id, parent)
if not parent:
ret, error = jagare.init(repo.get_real_path())
if not ret:
db.session.rollback()
return None, error
else:
ret, error = jagare.clone(repo.get_real_path(),
parent.get_real_path())
if error:
db.session.rollback()
return None, error
parent.forks = Repos.forks + 1
db.session.add(parent)
db.session.commit()
clear_repo_cache(repo, organization, team)
if parent:
clear_repo_cache(parent, organization, need=False)
clear_explore_cache(organization, repo.uid, team)
clear_commiter_cache(user, repo)
clear_watcher_cache(user, repo, organization, team)
return repo, None
except sqlalchemy.exc.IntegrityError, e:
db.session.rollback()
if 'Duplicate entry' in e.message:
return None, code.REPOS_PATH_EXISTS
logger.exception(e)
return None, code.UNHANDLE_EXCEPTION
def count_revisions(gid):
jagare = get_jagare(gist.id, gist.parent)
error, ret = jagare.get_log(gist.get_real_path(), total=1)
count = 0 if error else ret['total']
return count
def count_commits(gid, path):
jagare = get_jagare(repo.id, repo.parent)
error, ret = jagare.get_log(repo.get_real_path(), total=1, path=path)
count = 0 if error else ret['total']
return count