1. #!/usr/bin/env python
  2. # encoding: utf-8
  3.  
  4. """hgsite
  5.  
  6. Create and/or upload a static copy of the repository.
  7.  
  8. The main goal is sharing Mercurial on servers with only FTP access and
  9. statically served files, while providing the same information as hg
  10. serve and full solutions like bitbucket and gitorious (naturally
  11. without the interactivity).
  12. """
  13.  
  14. __copyright__ = """Copyright 2011 Arne Babenhauserheide
  15.  
  16. This software may be used and distributed according to the terms of the
  17. GNU General Public License version 2 or any later version.
  18. """
  19.  
  20. import os
  21. import shutil
  22. import re
  23. import mercurial
  24. import ftplib
  25. import socket
  26. import datetime
  27. from mercurial import cmdutil, util, scmutil
  28. from mercurial import commands, dispatch
  29. from mercurial.i18n import _
  30. from mercurial import hg, discovery, util, extensions
  31.  
  32. _staticidentifier = ".statichgrepo"
  33.  
  34. templates = {
  35.     "head": """<!DOCTYPE html>
  36. <html><head>
  37.     <meta charset="utf-8" />
  38.     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <!--duplicate for older browsers-->
  39.     <link rel="stylesheet" href="style.css" type="text/css" media="screen" />
  40.     <link rel="stylesheet" href="print.css" type="text/css" media="print" />
  41.     <title>{title}</title>
  42. </head>
  43. <body>
  44. <h1 id="maintitle">{reponame}</h1>
  45. """,
  46.     "srchead": """<!DOCTYPE html>
  47. <html><head>
  48.     <meta charset="utf-8" />
  49.     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <!--duplicate for older browsers-->
  50.     <link rel="stylesheet" href="style.css" type="text/css" media="screen" />
  51.     <link rel="stylesheet" href="print.css" type="text/css" media="print" />
  52.     <title>{filetitle}</title>
  53. </head>
  54. <body>
  55. """,
  56.     "forkhead": """<!DOCTYPE html>
  57. <html><head>
  58.     <meta charset="utf-8" />
  59.     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <!--duplicate for older browsers-->
  60.     <link rel="stylesheet" href="style.css" type="text/css" media="screen" />
  61.     <link rel="stylesheet" href="print.css" type="text/css" media="print" />
  62.     <title>{forkname}</title>
  63. </head>
  64. <body>
  65. <h1>{forkname} <small>(fork of <a href="../../">{reponame}</a>, found at {forkuri})</small></h1>
  66. """,
  67.     "foot": "</body></html>\n",
  68.     "screenstyle": """ """,
  69.     "printstyle": """ """,
  70.     "manifesthead": """<h2>""" + _("Commit (click to see the diff)")+""": <a href='../../commit/{hex}.html'>{hex}</a></h2>
  71. <p>{desc}</p><p>{user}</p>
  72.     <h2>""" + _("Diffstat") + """</h2>
  73. <pre>{diffstat}</pre>
  74.     <h2>""" + _("Files in this revision") + "</h2>", 
  75.     "commitlog": """\n<div style='float: right; padding-left: 0.5em'><em>({author|person})</em></div><strong> {date|shortdate}: <a href='{relativepath}src/{node}/index.html'>{desc|strip|fill68|firstline}</a></strong> <span style='font-size: xx-small'>{branches} {tags} {bookmarks}</span><p>{desc|escape}</p>\n""",
  76. }
  77.  
  78. _indexregexp = re.compile("^\\.*index.html$")
  79.  
  80.  
  81. def samefilecontent(filepath1, filepath2): 
  82.     """Check if the content of the two referenced files is equal."""
  83.     try: 
  84.         with open(filepath1) as f1: 
  85.             with open(filepath2) as f2: 
  86.                 return f1.read() == f2.read()
  87.     except OSError: return False
  88.  
  89. def contentequals(filepath, content): 
  90.     """Check if the files content is content."""
  91.     try: 
  92.         with open(filepath) as f: 
  93.             return f.read() == content
  94.     except OSError: return not content
  95.     except IOError: return False # file does not exist. Empty != not existing.
  96.     # TODO: check: return True if content is None?
  97.  
  98. def parsereadme(filepath, truncated=False):
  99.     """Parse the readme file"""
  100.     with open(filepath) as r:
  101.         readme = r.read()
  102.     if truncated:
  103.         return "<pre>" + "\n".join(readme.splitlines()[:5]) + "</pre>"
  104.     else: 
  105.         return "<pre>" + readme + "</pre>"
  106.  
  107. def overviewlogstring(ui, repo, revs, template=templates["commitlog"]): 
  108.     """Get the string for a log of the given revisions for the overview page."""
  109.     ui.pushbuffer()
  110.     t = cmdutil.changeset_templater(ui, repo, patch=False, diffopts=None, mapfile=None, buffered=False)
  111.     t.use_template(template.replace("{relativepath}", ""))
  112.     for c in revs:
  113.         ctx = repo.changectx(c)
  114.         t.show(ctx)
  115.     return ui.popbuffer()
  116.  
  117.  
  118. def writeoverview(ui, repo, target, name):
  119.     """Create the overview page"""
  120.     overview = ""
  121.     # get the title
  122.     overview += templates["head"].replace("{reponame}", name).replace("{title}", name)
  123.     # add a short identifier from the first line of the readme, if it
  124.     # exists # TODO: Parse different types of readme files
  125.     readme = name
  126.     for f in os.listdir(repo.root):
  127.         if f.lower().startswith("readme"):
  128.             readme = parsereadme(os.path.join(repo.root, f))
  129.             readme_intro = parsereadme(os.path.join(repo.root, f), truncated=True)
  130.             overview += "<div id='intro'>"
  131.             overview += readme_intro
  132.             overview += "</div>"
  133.             break
  134.     # now the links to the log and the files.
  135.     overview += "\n<p id='nav'><a href='commits'>changelog</a> | <a href='src/" + repo["tip"].hex() + "/'>files</a>"
  136.     # and the forks
  137.     forks = getforkinfo(ui, target)
  138.     if forks:
  139.         overview += " | " + _("forks: ")
  140.         for forkname, forkuri in forks.items():
  141.             overview += "<a href='" + getforkdir(target, forkname) + "'>" + forkname + "</a> "
  142.             incoming, fn, localother = getincoming(ui, repo, otheruri=forkuri, othername=forkname)
  143.             overview += "<small>(" + str(len(incoming))
  144.             outgoing, fn, localother = getoutgoing(ui, repo, otheruri=forkuri, othername=forkname)
  145.             overview += "<small>↓↑</small>" + str(len(outgoing)) + ")</small> "
  146.  
  147.     overview += "</p>"
  148.  
  149.     # now add the 5 most recent log entries
  150.     # divert all following ui output to a string, so we can just use standard functions
  151.     overview += "\n<div id='shortlog'><h2>Changes (<a href='commits'>full changelog</a>)</h2>\n"
  152.     ui.pushbuffer()
  153.     t = cmdutil.changeset_templater(ui, repo, patch=False, diffopts=None, mapfile=None, buffered=False)
  154.     t.use_template(templates["commitlog"].replace("{relativepath}", ""))
  155.     for c in range(1, min(len(repo.changelog), 5)):
  156.         ctx = repo.changectx(str(-c))
  157.         t.show(ctx)
  158.     overview += ui.popbuffer()
  159.     overview += "</div>"
  160.     
  161.     # Add branch, bookmark and tag information, if they exist.
  162.     branches = []
  163.     for branch, heads in repo.branchmap().items(): 
  164.         if branch and branch != "default": # not default
  165.             branches.extend(heads)
  166.  
  167.     try: 
  168.         tags = repo._tags
  169.     except AttributeError: 
  170.         tags = []
  171.     try: 
  172.         bookmarks = repo._bookmarks
  173.     except AttributeError:
  174.         bookmarks = []
  175.     if branches: # add branches
  176.         overview += "\n<div id='branches'><h2>Branches</h2>\n"
  177.         overview += overviewlogstring(ui, repo, branches,
  178.                                       template=templates["commitlog"].replace(
  179.                 "{branches}", "XXXXX").replace(
  180.                 "{date|shortdate}", "{branches}").replace(
  181.                 "XXXXX", "{date|shortdate}").replace(
  182.                 "{tags}", "XXXXX").replace(
  183.                 "{date|shortdate}", "{tags}").replace(
  184.                 "XXXXX", "{date|shortdate}"))
  185.         overview += "</div>"
  186.     if len(tags) > 1: 
  187.         overview += "\n<div id='tags'><h2>Tags</h2>\n"
  188.         overview += overviewlogstring(ui, repo, [tags[t] for t in tags if t != "tip"],
  189.                                       template=templates["commitlog"].replace(
  190.                 "{tags}", "XXXXX").replace(
  191.                 "{date|shortdate}", "{tags}").replace(
  192.                 "XXXXX", "{date|shortdate}"))
  193.         overview += "</div>"
  194.     if len(bookmarks): 
  195.         overview += "\n<div id='bookmarks'><h2>Bookmarks</h2>\n"
  196.         overview += overviewlogstring(ui, repo, bookmarks.values(),
  197.                                       template=templates["commitlog"].replace(
  198.                 "{bookmarks}", "XXXXX").replace(
  199.                 "{date|shortdate}", "{bookmarks}").replace(
  200.                 "XXXXX", "{date|shortdate}"))
  201.         overview += "</div>"
  202.     # add the full readme
  203.     overview += "<div id='readme'><h2>"+_("Readme")+"</h2>\n"
  204.     overview += readme
  205.     overview += "</div>"
  206.  
  207.     # finish the overview
  208.     overview += templates["foot"]
  209.     indexfile = os.path.join(target, "index.html")
  210.     if not contentequals(indexfile, overview): 
  211.         with open(indexfile, "w") as f: 
  212.             f.write(overview)
  213.  
  214. def writelog(ui, repo, target, name):
  215.     """Write the full changelog, in steps of 100."""
  216.     commits = os.path.join(target, "commits")
  217.  
  218.     # create the folders
  219.     if not os.path.isdir(commits):
  220.         os.makedirs(commits)
  221.     for i in range(len(repo.changelog)/100):
  222.         d = commits+"-"+str(i+1)+"00"
  223.         if not os.path.isdir(d):
  224.             os.makedirs(d)
  225.  
  226.     # create the log files
  227.     t = cmdutil.changeset_templater(ui, repo, patch=False, diffopts=None, mapfile=None, buffered=False)
  228.     t.use_template(templates["commitlog"].replace("{relativepath}", "../"))
  229.     logs = []
  230.     for ck in range(len(repo.changelog)/100+1):
  231.         ui.pushbuffer()
  232.         if ck:
  233.             dd = d
  234.             di = str(ck)+"00"
  235.             d = commits+"-"+di
  236.             logs[-1][-1] += "<p><a href=\"../commits-"+di+"\">earlier</a></p>"
  237.             if ck>2:
  238.                 # the older log gets a reference to the newer one
  239.                 logs[-1][-1] += "<p><a href=\"../commits-"+str(ck-2)+"00"+"\">later</a></p>"
  240.             elif ck>1:
  241.                 logs[-1][-1] += "<p><a href=\"../commits\">later</a></p>"
  242.             logs.append([os.path.join(d, "index.html"), ""])
  243.         else:
  244.             d = commits
  245.             logs.append([os.path.join(d, "index.html"), ""])
  246.  
  247.         logs[-1][-1] += templates["head"].replace("{reponame}", "<a href='../'>"+name+"</a>").replace("{title}", name)
  248.         for c in range(ck*100+1, min(len(repo.changelog)+1, (ck+1)*100)):
  249.             ctx = repo.changectx(str(-c))
  250.             t.show(ctx)
  251.         logs[-1][-1] += ui.popbuffer()
  252.  
  253.     for filepath,data in logs:
  254.         data += templates["foot"].replace("{reponame}", "<a href='../'>"+name+"</a>")
  255.         if not contentequals(filepath,data): 
  256.             with open(filepath, "w") as f: 
  257.                 f.write(data)
  258.  
  259. def getlocalother(repo, ui, otheruri, othername):
  260.     """Get a local clone of the repo identified by uri and name within .hg/paths.
  261.  
  262.     This creates that local clone!
  263.     """
  264.     # if we cannot get the changes via bundlerepo, we create a
  265.     # local clone in .hg/paths/<othername>-<sha1-of-otheruri> and
  266.     # check from there.  in case that local clone already exists,
  267.     # we tell it to pull there.  The hash is necessary to prevent
  268.     # collisions when the uri changes.
  269.     if othername is None:
  270.         othername = ""
  271.     urihash = util.sha1(otheruri).hexdigest()
  272.     localcopy = os.path.join(repo.root, ".hg", "paths", 
  273.                      othername+"-"+urihash)
  274.     # if getting remote changes directly fails, we take the
  275.     # completely safe path: dispatch uses the only really stable
  276.     # interface: the cli.
  277.     if os.path.isdir(localcopy):
  278.         req = dispatch.request(["-R", localcopy, "pull", otheruri])
  279.     else:
  280.         req = dispatch.request(["clone", otheruri, localcopy], ui=ui)
  281.     dispatch.dispatch(req)
  282.     other = hg.peer(repo, {}, localcopy)
  283.     return other
  284.  
  285. def getincoming(ui, repo, otheruri, other=None, othername=None):
  286.     """Get incoming changes."""
  287.     # Note: We cannot just use getcommonincoming and I do not yet know
  288.     # how to use its output to get good changes. TODO: do this nicer.
  289.     def cleanupfn():
  290.         """non-operation cleanup function (default)."""
  291.         pass
  292.     # cannot do that for ftp or freenet insertion uris (freenet
  293.     # separates insertion and retrieval by private/public key)
  294.     isftpuri = otheruri.startswith("ftp://")
  295.     isfreenetpriv = "AQECAAE/" in otheruri
  296.     if isftpuri or isfreenetpriv:
  297.         chlist = []
  298.         return chlist, cleanupfn, other
  299.  
  300.     if not other:
  301.         other = hg.peer(repo, {}, otheruri)
  302.     ui.pushbuffer() # ignore ui events
  303.     source, branches = hg.parseurl(otheruri, None)
  304.     revs, checkout = hg.addbranchrevs(repo, other, branches, None)
  305.     if revs:
  306.         revs = [other.lookup(rev) for rev in revs]
  307.     try: # FIXME: This breaks on http repos! 
  308.         other, chlist, cleanupfn = hg.bundlerepo.getremotechanges(ui, repo, other,
  309.                                                                revs, False, False)
  310.     except (AttributeError, util.Abort):
  311.         other = getlocalother(repo, ui, otheruri, othername)
  312.         other, chlist, cleanupfn = hg.bundlerepo.getremotechanges(ui, repo, other,
  313.                                                                revs, False, False)
  314.         
  315.     ui.popbuffer()
  316.     return chlist, cleanupfn, other
  317.  
  318. def getoutgoing(ui, repo, otheruri, other=None, othername=None):
  319.     def cleanupfn():
  320.         """non-operation cleanup function (default)."""
  321.         pass
  322.     # cannot do that for ftp or freenet insertion uris (freenet
  323.     # separates insertion and retrieval by private/public key)
  324.     isftpuri = otheruri.startswith("ftp://")
  325.     isfreenetpriv = "AQECAAE/" in otheruri
  326.     if isftpuri or isfreenetpriv:
  327.         chlist = []
  328.         return chlist, cleanupfn, other
  329.  
  330.     if not other: 
  331.         other = hg.peer(repo, {}, otheruri)
  332.  
  333.     def outgoingchanges(repo, other):
  334.         from mercurial import discovery
  335.         fco = discovery.findcommonoutgoing
  336.         try:
  337.             og = fco(repo, other, force=True)
  338.             return og.missing
  339.         except AttributeError: # old client
  340.             common, outheads = og
  341.             o = repo.changelog.findmissing(common=common, heads=outheads)
  342.             return o
  343.             
  344.     other.ui.pushbuffer() # ignore ui events
  345.  
  346.     try:
  347.         chlist = outgoingchanges(repo, other)
  348.     except (AttributeError, util.Abort):
  349.         other.ui.popbuffer()
  350.         other = getlocalother(repo, ui, otheruri, othername)
  351.         other.ui.pushbuffer()
  352.         chlist = outgoingchanges(repo, other)
  353.  
  354.     other.ui.popbuffer()
  355.     return chlist, cleanupfn, other
  356.  
  357.  
  358. def getforkinfo(ui, target):
  359.     """Name and Uri of all forks."""
  360.     forks = dict(ui.configitems("paths"))
  361.     forkinfo = {}
  362.     for forkname, forkuri in forks.items():
  363.         # ignore the static repo
  364.         if os.path.abspath(forkuri) == os.path.abspath(target):
  365.             continue
  366.         forkinfo[forkname] = forkuri
  367.     return forkinfo
  368.  
  369. def safeuri(uri):
  370.     """Shareable uris: Hide password + hide freenet insert keys."""
  371.     uri = util.hidepassword(uri)
  372.     freenetpriv = "AQECAAE/"
  373.     if "USK@" in uri and freenetpriv in uri:
  374.         uri = "freenet://USK@******" + uri[uri.index(freenetpriv)+len(freenetpriv)-1:]
  375.     return uri
  376.  
  377. def getforkdata(ui, repo, target, name, forkname, forkuri):
  378.     """Write the site for a single fork."""
  379.     # make sure the forkdir exists.
  380.     other = hg.peer(repo, {}, forkuri)
  381.  
  382.     # incrementally build the html
  383.     html = templates["forkhead"].replace(
  384.             "{forkname}", forkname).replace(
  385.         "{reponame}", name).replace(
  386.                 "{forkuri}", safeuri(forkuri))
  387.  
  388.     # prepare the log templater
  389.     t = cmdutil.changeset_templater(ui, repo, patch=False, diffopts=None, mapfile=None, buffered=False)
  390.     t.use_template(templates["commitlog"].replace(
  391.             "{relativepath}", "../"))
  392.  
  393.     # Add incoming commits
  394.     html += "<div id='incoming'><h2>Incoming commits</h2>"
  395.     chlist, cleanupfn, localother = getincoming(ui, repo, otheruri=forkuri, other=other, othername=forkname)
  396.     
  397.     ui.pushbuffer()
  398.     for ch in chlist:
  399.         ctx = localother.changectx(ch)
  400.         t.show(ctx)
  401.     html += ui.popbuffer()
  402.     cleanupfn()
  403.  
  404.     # add outgoing commits
  405.     html += "<div id='outgoing'><h2>Outgoing commits</h2>"
  406.     chlist, cleanupfn, localother = getoutgoing(ui, repo, forkuri, other=other, othername=forkname)
  407.  
  408.     ui.pushbuffer()
  409.     for ch in chlist:
  410.         ctx = repo.changectx(ch)
  411.         t.show(ctx)
  412.     html += ui.popbuffer()
  413.     cleanupfn()
  414.     
  415.     html += "</div>"
  416.     html += templates["foot"]
  417.     return html
  418.  
  419. def getforkdir(target, forkname):
  420.     return os.path.join("forks", forkname)
  421.  
  422. def writeforks(ui, repo, target, name):
  423.     """Write an info-page for each fork, defined in hg paths.
  424.  
  425.     relevant data: incoming commits, outgoing commits, branches and bookmarks not in fork or not in repo. Short: incoming (commits, branches, bookmarks), outgoing (incoming first means, we consider this repo to be the main repo).
  426.     """
  427.     forkinfo = getforkinfo(ui, target)
  428.     for forkname, forkuri in forkinfo.items():
  429.         # ignore the static repo itself
  430.         if os.path.abspath(forkuri) == os.path.abspath(target):
  431.             continue
  432.         forkdir = getforkdir(target, forkname)
  433.         if not os.path.isdir(os.path.join(target, forkdir)):
  434.             os.makedirs(os.path.join(target, forkdir))
  435.         with open(os.path.join(target, forkdir, "index.html"), "w") as f:
  436.             f.write(
  437.                 getforkdata(ui, repo, target, name, forkname, forkuri))
  438.  
  439.  
  440. def writecommits(ui, repo, target, name, force=False):
  441.     """Write all not yet existing commit files."""
  442.     commit = os.path.join(target, "commit")
  443.  
  444.     # create the folders
  445.     if not os.path.isdir(commit):
  446.         os.makedirs(commit)
  447.  
  448.     t = cmdutil.changeset_templater(ui, repo, patch=False, diffopts=None, mapfile=None, buffered=False)
  449.     t.use_template(templates["commitlog"].replace("{relativepath}", "../"))
  450.     for c in range(len(repo.changelog)):
  451.         ctx = repo.changectx(str(c))
  452.         cpath = os.path.join(commit, ctx.hex() + ".html")
  453.         if not force and os.path.isfile(cpath):
  454.             continue
  455.         with open(cpath, "w") as cf:
  456.             cf.write(templates["head"].replace("{reponame}", "<a href='../'>"+name+"</a>").replace("{title}", name))
  457.             ui.pushbuffer()
  458.             t.show(ctx)
  459.             cf.write(ui.popbuffer())
  460.             ui.pushbuffer()
  461.             commands.diff(ui, repo, change=str(c), git=True)
  462.             cf.write("<pre>"+ui.popbuffer().replace("<", "<")+"</pre>")
  463.             cf.write(templates["foot"].replace("{reponame}", "<a href='../'>"+name+"</a>"))
  464.  
  465.  
  466. def escapename(filename):
  467.     """escape index.html as .index.html and .ind… as ..ind… and so fort."""
  468.     if _indexregexp.match(filename) is not None:
  469.         return "." + filename
  470.     else: return filename
  471.  
  472.  
  473. def parsesrcdata(data):
  474.     """Parse a src file into a html file."""
  475.     return "<pre>"+data.replace("<", "<")+"</pre>"
  476.  
  477. def srcpath(target, ctx, filename):
  478.     """Get the relative path to the static sourcefile for an already escaped filename."""
  479.     return os.path.join(target,"src",ctx.hex(),filename+".html")
  480.  
  481. def rawpath(target, ctx, filename):
  482.     """Get the relative path to the static sourcefile for an already escaped filename."""
  483.     return os.path.join(target,"raw",ctx.hex(),filename)
  484.  
  485. def ctxdiffstat(ui, repo, ctx):
  486.     """Get the diffstat of a change context."""
  487.     command = "log -r " + ctx.hex() + " --stat --color=never"
  488.     req = dispatch.request(command.split(), ui=ui, repo=repo)
  489.     ui.pushbuffer()
  490.     dispatch.dispatch(req)
  491.     # FIXME: remove the color in an elegant way instead of fudging like this.
  492.     return ui.popbuffer().replace(
  493.         "[0;33m","").replace(
  494.         "[0;32m","").replace(
  495.             "[0m", "").replace(
  496.             "[0;31m", "").replace(
  497.                 "","")
  498.     
  499. def createindex(ui, repo, target, ctx):
  500.     """Create an index page for the changecontext: the commit message + the user + all files in the changecontext."""
  501.     # first the head
  502.     index = templates["manifesthead"].replace(
  503.         "{hex}", ctx.hex()).replace(
  504.         "{desc}", ctx.description()).replace(
  505.             "{user}", ctx.user()).replace(
  506.                 "{diffstat}", ctxdiffstat(ui, repo, ctx))
  507.     # then the files
  508.     index += "<ul>"
  509.     for filename in ctx:
  510.         filectx = ctx[filename]
  511.         lasteditctx = filectx.filectx(filectx.filerev())
  512.         index += "<li><a href='../../"+ os.path.join("src",lasteditctx.hex(), escapename(filename)+".html") + "'>" + filename + "</a>"# (<a href='../../" + os.path.join("raw",lasteditctx.hex(), filename) + "'>raw</a>)</li>"
  513.     index += "</ul>"
  514.     return index
  515.  
  516. def writesourcetree(ui, repo, target, name, force, rawfiles=False):
  517.     """Write manifests for all commits and websites for all files.
  518.  
  519.     * For each file, write sites for all revisions where the file was changed: under src/<hex>/path as html site (with linenumbers and maybe colored source), under raw/<hex>/<path> as plain files. If there is an index.html file, write it as .index.html. If there also is .index.html, turn it to ..index.html, …
  520.     * For each commit write an index with links to the included files at their latest revisions before/at the commit.
  521.     """
  522.     # first write all files in all commits.
  523.     for c in range(len(repo.changelog)):
  524.         ctx = repo.changectx(str(c))
  525.         for filename in ctx.files():
  526.             try:
  527.                 filectx = ctx.filectx(filename)
  528.             except LookupError, e:
  529.                 ui.warn("File not found, likely moved ", e, "\n")
  530.             if rawfiles: 
  531.                 # first write the raw data
  532.                 filepath = rawpath(target,ctx,filectx.path())
  533.                 # skip already existing files
  534.                 if not force and os.path.isfile(filepath):
  535.                     continue
  536.                 try:
  537.                     os.makedirs(os.path.dirname(filepath))
  538.                 except OSError: pass # exists
  539.                 with open(filepath, "w") as f:
  540.                     f.write(filectx.data())
  541.             # then write it as html
  542.             _filenameescaped = escapename(filectx.path())
  543.             filepath = srcpath(target,ctx,_filenameescaped)
  544.             if not force and os.path.isfile(filepath):
  545.                 continue
  546.             try:
  547.                 os.makedirs(os.path.dirname(filepath))
  548.             except OSError: pass # exists
  549.             with open(filepath, "w") as f:
  550.                 f.write(templates["srchead"].replace("{filetitle}", name+": " + filename))
  551.                 f.write(parsesrcdata(filectx.data()))
  552.                 f.write(templates["foot"].replace("{reponame}", name))
  553.     # then write manifests for all commits
  554.     for c in range(len(repo.changelog)):
  555.         ctx = repo.changectx(str(c))
  556.         filepath = os.path.join(target,"src",ctx.hex(),"index.html")
  557.         # skip already existing files
  558.         if not force and os.path.isfile(filepath):
  559.             continue
  560.         try:
  561.             os.makedirs(os.path.dirname(filepath))
  562.         except OSError: pass # exists
  563.         with open(filepath, "w") as f:
  564.             f.write(templates["head"].replace("{reponame}", "<a href='../../'>"+name+"</a>").replace("{title}", name))
  565.             f.write(createindex(ui, repo, target, ctx))
  566.             f.write(templates["foot"].replace("{reponame}", "<a href='../../'>"+name+"</a>"))
  567.  
  568. def parsesite(ui, repo, target, **opts):
  569.     """Create the static folder."""
  570.     idfile = os.path.join(target, _staticidentifier)
  571.     if not os.path.isdir(target):
  572.         # make sure the target exists
  573.         os.makedirs(target)
  574.     else: # make sure it is a staticrepo
  575.         if not os.path.isfile(idfile):
  576.             if not ui.prompt("The target folder " + target + " has not yet been used as static repo. Really use it? (y/N)", default="n").lower() in ["y", "yes"]:
  577.                 return
  578.             with open(idfile, "w") as i:
  579.                 i.write("")
  580.  
  581.     if opts["sitename"]:
  582.         name = opts["sitename"]
  583.     elif target != "static": name = target
  584.     else: name = os.path.basename(repo.root)
  585.  
  586.     # first the stylesheets
  587.     screenstyle = opts["screenstyle"]
  588.     screenfile = os.path.join(target, "style.css")
  589.     if screenstyle and not samefilecontent(screenstyle, screenfile):
  590.         shutil.copyfile(screenstyle, screenfile)
  591.     elif not contentequals(screenfile,templates["screenstyle"]):
  592.         with open(screenfile, "w") as f:
  593.             f.write(templates["screenstyle"])
  594.     printstyle = opts["printstyle"]
  595.     printfile = os.path.join(target, "print.css")
  596.     if printstyle and not samefilecontent(printstyle, printfile):
  597.         shutil.copyfile(printstyle, printfile)
  598.     elif not contentequals(printfile, templates["printstyle"]):
  599.         with open(printfile, "w") as f:
  600.             f.write(templates["printstyle"])
  601.  
  602.     # then the overview
  603.     writeoverview(ui, repo, target, name)
  604.  
  605.     # and the log
  606.     writelog(ui, repo, target, name)
  607.  
  608.     # and all commit files
  609.     writecommits(ui, repo, target, name, force=opts["force"])
  610.  
  611.     # and all file data
  612.     writesourcetree(ui, repo, target, name, force=opts["force"])
  613.  
  614.     # and all forks
  615.     writeforks(ui, repo, target, name)
  616.  
  617.  
  618. def addrepo(ui, repo, target, bookmarks, force):
  619.     """Add the repo to the target and make sure it is up to date."""
  620.     try:
  621.         commands.init(ui, dest=target)
  622.     except mercurial.error.RepoError, e:
  623.         # already exists
  624.         pass
  625.  
  626.     ui.pushbuffer()
  627.     if bookmarks: 
  628.         commands.push(ui, repo, dest=target, bookmark=repo._bookmarks, force=force)
  629.     else: 
  630.         commands.push(ui, repo, dest=target, force=force)
  631.     ui.popbuffer()
  632.  
  633.  
  634. def upload(ui, repo, target, ftpstring, force):
  635.     """upload the repo to the FTP server identified by the ftp string."""
  636.     try:
  637.         user, password = ftpstring.split("@")[0].split(":")
  638.         serverandpath = "@".join(ftpstring.split("@")[1:])
  639.     except ValueError:
  640.         ui.warn(_("FTP-upload: No @ in FTP-Url. We try anonymous access.\n"))
  641.         user, password = "anonymous", ""
  642.         serverandpath = ftpstring # no @, so we just take the whole string
  643.     server = serverandpath.split("/")[0]
  644.     ftppath = "/".join(serverandpath.split("/")[1:])
  645.     timeout = 10
  646.     try:
  647.         ftp = ftplib.FTP(server, user, password, "", timeout)
  648.     except socket.timeout:
  649.         ui.warn(_("connection to "), server, _(" timed out after "), timeout, _(" seconds.\n"))
  650.         return
  651.  
  652.     ui.status(ftp.getwelcome(), "\n")
  653.  
  654.     # create the target dir.
  655.     serverdir = os.path.dirname(ftppath)
  656.     serverdirparts = ftppath.split("/")
  657.     sd = serverdirparts[0]
  658.     if not sd in ftp.nlst():
  659.         ftp.mkd(sd)
  660.     for sdp in serverdirparts[1:]:
  661.         sdo = sd
  662.         sd = os.path.join(sd, sdp)
  663.         if not sd in ftp.nlst(sdo):
  664.             ftp.mkd(sd)
  665.  
  666.  
  667.     ftp.cwd(ftppath)
  668.     if not ftp.pwd() == "/" + ftppath:
  669.         ui.warn(_("not in the correct ftp directory. Cowardly bailing out.\n"))
  670.         return
  671.  
  672.     #ftp.dir()
  673.     #return
  674.     ftpfeatures = ftp.sendcmd("FEAT")
  675.     featuremtime = " MDTM" in ftpfeatures.splitlines()
  676.     _ftplistcache = set()
  677.  
  678.     for d, dirnames, filenames in os.walk(target):
  679.         for filename in filenames:
  680.             localfile = os.path.join(d, filename)
  681.             serverfile = localfile[len(target)+1:]
  682.             serverdir = os.path.dirname(serverfile)
  683.             serverdirparts = serverdir.split("/")
  684. #            print serverdirparts, serverfile
  685.             with open(localfile, "rb") as f:
  686.                 sd = serverdirparts[0]
  687.                 if sd and not sd in _ftplistcache: # should happen only once per superdir
  688.                     _ftplistcache.update(set(ftp.nlst()))
  689.                 if sd and not sd in _ftplistcache:
  690.                     try:
  691.                         ui.status(_("creating directory "), sd, "\n")
  692.                         ftp.mkd(sd)
  693.                         _ftplistcache.add(sd)
  694.                     except ftplib.error_perm, resp:
  695.                         ui.warn(_("could not create directory "), sd, ": " , resp, "\n")
  696.                     else: _ftplistcache.add(sd)
  697.  
  698.                 for sdp in serverdirparts[1:]:
  699.                     sdold = sd
  700.                     sd = os.path.join(sd, sdp)
  701.                     #print sd, sdp
  702.                     #print ftp.nlst(sdold)
  703.                     if sd and not sd in _ftplistcache: # should happen only once per superdir
  704.                         _ftplistcache.update(set(ftp.nlst(sdold)))
  705.                     if sd and not sd in _ftplistcache:
  706.                         try:
  707.                             ui.status(_("creating directory "), sd, "\n")
  708.                             ftp.mkd(sd)
  709.                             _ftplistcache.add(sd)
  710.                         except ftplib.error_perm, resp:
  711.                             ui.warn(_("could not create directory "),
  712.                                     sd, ": " , resp, "\n")
  713.  
  714.                 if not serverfile in _ftplistcache: # should happen for existing files only once per dir.
  715.                     _ftplistcache.update(set(ftp.nlst(serverdir)))
  716.                 if not serverfile in _ftplistcache or force:
  717.                     if force:
  718.                         ui.status(_("uploading "), serverfile,
  719.                                   _(" because I am forced to.\n"))
  720.                     else:
  721.                         ui.status(_("uploading "), serverfile,
  722.                                   _(" because it is not yet online.\n"))
  723.  
  724.                     ftp.storbinary("STOR "+ serverfile, f)
  725.                 else:
  726.                     # reupload the file if the file on the server is older than the local file.
  727.                     if featuremtime:
  728.                         ftpmtime = ftp.sendcmd("MDTM " + serverfile).split()[1]
  729.                         localmtime = os.stat(localfile).st_mtime
  730.                         localmtimestr = datetime.datetime.utcfromtimestamp(localmtime).strftime("%Y%m%d%H%M%S")
  731.                         newer = int(localmtimestr) > int(ftpmtime)
  732.                         if newer:
  733.                             ui.status(_("uploading "), serverfile,
  734.                                       _(" because it is newer than the file on the FTP server.\n"))
  735.                             ftp.storbinary("STOR "+ serverfile, f)
  736.  
  737.  
  738.  
  739. def staticsite(ui, repo, target=None, **opts):
  740.     """Create a static copy of the repository and/or upload it to an FTP server."""
  741.     if repo.root == target:
  742.         ui.warn(_("static target repo can’t be the current repo"))
  743.         return
  744.     if not target: target = "static"
  745.     #print repo["."].branch()
  746.     # add the hg repo to the static site
  747.     # currently we need to either include all bookmarks or not, because we don’t have the remote repo when parsing the site.
  748.     # TODO: I don’t know if that is the correct way to go. Maybe always push all.
  749.     bookmark = opts["bookmark"]
  750.     addrepo(ui, repo, target, bookmark, force=opts["force"])
  751.     # first: just create the site.
  752.     parsesite(ui, repo, target, **opts)
  753.     if opts["upload"]:
  754.         # upload the repo
  755.         upload(ui, repo, target, opts["upload"], opts["force"])
  756.  
  757.  
  758. cmdtable = {
  759.     # "command-name": (function-call, options-list, help-string)
  760.     "site": (staticsite,
  761.                      [
  762.                       #('r', 'rev', None, 'parse the given revision'),
  763.                       #('a', 'all', None, 'parse all revisions (requires much space)'),
  764.                       ('n', 'sitename', "", 'the repo name. Default: folder or last segment of the repo-path.'),
  765.                       ('u', 'upload', "", 'upload the repo to the given ftp host. Format: user:password@host/path/to/dir'),
  766.                       ('f', 'force', False, 'force recreating all commit files. Slow.'),
  767.                       ('s', 'screenstyle', "", 'use a custom stylesheet for display on screen'),
  768.                       ('p', 'printstyle', "", 'use a custom stylesheet for printing'),
  769.                       ('B', 'bookmark', False, 'include the bookmarks')],
  770.                      "[options] [folder]")
  771. }
  772.  
  773. ## add ftp as scheme to be handled by this plugin.
  774.  
  775. wrapcmds = { # cmd: generic, target, fixdoc, ppopts, opts
  776.     'push': (False, None, False, False, [
  777.         ('', 'staticsite', None, 'show parent svn revision instead'),
  778.     ])
  779. }
  780.  
  781. ## Explicitely wrap functions to change local commands in case the remote repo is an FTP repo. See mercurial.extensions for more information.
  782. # Get the module which holds the functions to wrap
  783. # the new function: gets the original function as first argument and the originals args and kwds.
  784. def findcommonoutgoing(orig, *args, **opts):
  785.     repo = args[1]
  786.     capable = getattr(repo, 'capable', lambda x: False)
  787.     if capable('ftp'):
  788.         class fakeoutgoing(object):
  789.             def __init__(self):
  790.                 self.excluded = []
  791.                 self.missing = []
  792.                 self.commonheads = []
  793.         return fakeoutgoing()
  794.     else:
  795.         return orig(*args, **opts)
  796. # really wrap the functions
  797. extensions.wrapfunction(discovery, 'findcommonoutgoing', findcommonoutgoing)
  798.  
  799. # explicitely wrap commands in case the remote repo is an FTP repo.
  800. def ftppush(orig, *args, **opts):
  801.     try:
  802.         ui, repo, path = args
  803.         path = ui.expandpath(path)
  804.     except ValueError: # no ftp string
  805.         ui, repo = args
  806.         path = ui.expandpath('default-push', 'default')
  807.     # only act differently, if the target is an FTP repo.
  808.     if not path.startswith("ftp"):
  809.         return orig(*args, **opts)
  810.     # first create the site at ._site
  811.     target = "._site"
  812.     ftpstring = path.replace("ftp://", "")
  813.     # fix the options to fit those of the site command
  814.     opts["name"] = opts["sitename"]
  815.     opts["upload"] = ftpstring
  816.     staticsite(ui, repo, target, **opts)
  817.     return 0
  818.         
  819. # really wrap the command
  820. siteopts = [('', 'sitename', "", 'staticsite: the title of the site. Default: folder or last segment of the repo-path.'),
  821.             ('', 'screenstyle', "", 'use a custom stylesheet for display on screen'),
  822.             ('', 'printstyle', "", 'use a custom stylesheet for printing')]
  823. entry = extensions.wrapcommand(commands.table, "push", ftppush)
  824. entry[1].extend(siteopts)
  825.  
  826. # Starting an FTP repo. Not yet used, except for throwing errors for missing commands and faking the lock.
  827.  
  828. # TODO: repo -> peer
  829. from mercurial import util
  830. try:
  831.     from mercurial.peer import peerrepository
  832. except ImportError:
  833.     from mercurial.repo import repository as peerrepository
  834. try:
  835.     from mercurial.error import RepoError
  836. except ImportError:
  837.     from mercurial.repo import RepoError
  838.  
  839. # TODO: repo -> peer
  840. class FTPRepository(peerrepository):
  841.     def __init__(self, ui, path, create):
  842.         self.create = create
  843.         self.ui = ui
  844.         self.path = path
  845.         self.capabilities = set(["ftp"])
  846.  
  847.     def lock(self):
  848.         """We cannot really lock FTP repos, yet.
  849.  
  850.         TODO: Implement as locking the repo in the static site folder."""
  851.         class DummyLock:
  852.             def release(self):
  853.                 pass
  854.         l = DummyLock()
  855.         return l
  856.  
  857.     def url(self):
  858.         return self.path
  859.  
  860.     def lookup(self, key):
  861.         return key
  862.  
  863.     def cancopy(self):
  864.         return False
  865.  
  866.     def heads(self, *args, **opts):
  867.         """
  868.         Whenever this function is hit, we abort. The traceback is useful for
  869.         figuring out where to intercept the functionality.
  870.         """
  871.         raise util.Abort('command heads unavailable for FTP repositories')
  872.  
  873.     def pushkey(self, namespace, key, old, new):
  874.         return False
  875.  
  876.     def listkeys(self, namespace):
  877.         return {}
  878.  
  879.     def push(self, remote, force=False, revs=None, newbranch=None):
  880.         raise util.Abort('command push unavailable for FTP repositories')
  881.     
  882.     def pull(self, remote, heads=[], force=False):
  883.         raise util.Abort('command pull unavailable for FTP repositories')
  884.     
  885.     def findoutgoing(self, remote, base=None, heads=None, force=False):
  886.         raise util.Abort('command findoutgoing unavailable for FTP repositories')
  887.  
  888.  
  889. class RepoContainer(object):
  890.     def __init__(self):
  891.         pass
  892.  
  893.     def __repr__(self):
  894.         return '<FTPRepository>'
  895.  
  896.     def instance(self, ui, url, create):
  897.         # Should this use urlmod.url(), or is manual parsing better?
  898.         #context = {}
  899.         return FTPRepository(ui, url, create)
  900.  
  901. hg.schemes["ftp"] = RepoContainer()
  902.  
  903. def test():
  904.     import subprocess as sp
  905.     def showcall(args):
  906.         print args
  907.         sp.call(args)
  908.     os.chdir(os.path.dirname(__file__))
  909.     # just check if loading the extension works
  910.     showcall(["hg", "--config", "extensions.site="+__file__])
  911.     # check if I can create a site
  912.     showcall(["hg", "--config", "extensions.site="+__file__, "site", "-B", "-n", "mysite"])
  913.     # check if uploading works: Only a valid test, if you have a
  914.     # post-push hook which does the uploading
  915.     showcall(["hg", "--config", "extensions.site="+__file__, "push"])
  916.     # check if push directly to ftp works. Requires the path draketo
  917.     # to be set up in .hg/hgrc as ftp://user:password/path
  918.     showcall(["hg", "--config", "extensions.site="+__file__, "push", "draketo", "--sitename", "site extension"])
  919.  
  920. if __name__ == "__main__":
  921.     test()