/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2008 Sun Microsystems, Inc.

 */

package org.netbeans.nbbuild.extlibs;

import java.io.BufferedReader;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.apache.tools.ant.BuildException;

import org.apache.tools.ant.Project;

import org.apache.tools.ant.Task;

import org.netbeans.nbbuild.HgExec;

/**

 * Registers external.py as a Mercurial encode/decode hook, if appropriate.

 */

public class RegisterExternalHook extends Task {

    public RegisterExternalHook() {}

    private File root;

    /** Location of NB source root. */

    public void setRoot(File root) {

        this.root = root;

    }

    private File hook;

    /** Extension hook to register. */

    public void setHook(File hook) {

        this.hook = hook;

    }

    private static final String BINARIES = "*/external/*.{zip,jar,gz,bz2,gem,dll}";

    @Override

    public void execute() throws BuildException {

        File dotHg = new File(root, ".hg");

        if (!dotHg.isDirectory()) {

            log(root + " is not a Mercurial repository", Project.MSG_VERBOSE);

            return;

        }

        List<String> hgExecutable = HgExec.hgExecutable();

        try {

            List<String> commandAndArgs = new ArrayList<String>(hgExecutable);

            commandAndArgs.add("showconfig");

            Process p = new ProcessBuilder(commandAndArgs).directory(root).start();

            BufferedReader r = new BufferedReader(new InputStreamReader(p.getInputStream()));

            String line;

            while ((line = r.readLine()) != null) {

                if (line.matches("(en|de)code\\.\\*\\*=.*")) {

                    // XXX try to fix it instead

                    // Tricky because no trivial way to find where Mercurial.ini is.

                    // If Hg installed to default Python path, could use:

                    // python -c 'from mercurial import util; print util.rcpath()'

                    // ({}** chosen because it sorts after */external/*.ext so will not take precedence.)

                    throw new BuildException(

                            "An existing global encode/decode hook will conflict with " + hook.getName() + "\n" +

                            "You must edit your Mercurial.ini and change '** = ...' in encode/decode sections to '{}** = ...'", getLocation());

                }

            }

        } catch (IOException x) {

            log("Could not verify Hg configuration: " + x, Project.MSG_WARN);

        }

        File[] repos = {

            root,

            new File(root, "contrib"),

        };

        for (File repo : repos) {

            dotHg = new File(repo, ".hg");

            if (!dotHg.isDirectory()) {

                log(repo + " is not a Mercurial repository", Project.MSG_VERBOSE);

                continue;

            }

            try {

                File hgrc = new File(dotHg, "hgrc");

                ByteArrayOutputStream baos = new ByteArrayOutputStream();

                if (hgrc.isFile()) {

                    InputStream is = new FileInputStream(hgrc);

                    try {

                        byte[] buf = new byte[4096];

                        int read;

                        while ((read = is.read(buf)) != -1) {

                            baos.write(buf, 0, read);

                        }

                    } finally {

                        is.close();

                    }

                }

                String config = baos.toString();

                if (Pattern.compile("(?m)^external *= *" + Pattern.quote(hook.getAbsolutePath()) + "$").matcher(config).find()) {

                    log("Hook already registered in " + hgrc, Project.MSG_VERBOSE);

                    continue;

                }

                if (Pattern.compile("(?m)^external *=").matcher(config).find()) {

                    log("Hook already registered in " + hgrc + " in wrong location, correcting...", Project.MSG_WARN);

                    config = config.replaceFirst("(?m)^external *=.*$", "external = " + hook.toString().replaceAll("\\\\", "\\\\\\\\"));

                } else {

                    log("Registering hook in " + hgrc);

                    String nl = System.getProperty("line.separator");

                    if (config.length() > 0) {

                        config += nl;

                    }

                    config += "[extensions]" + nl + "external = " + hook + nl + "[encode]" + nl;

                    Matcher m = Pattern.compile("https://[a-zA-Z0-9_]+(:[^@]+)?@hg.netbeans.org/").matcher(config);

                    if (m.find()) {

                        config += BINARIES + " = upload: " + m.group() + "binaries/upload" + nl;

                    } else {

                        config += "# To preauthenticate, use: https://jhacker:secret@hg.netbeans.org/binaries/upload" + nl +

                                BINARIES + " = upload: https://hg.netbeans.org/binaries/upload" + nl;

                    }

                    config += "[decode]" + nl + BINARIES + " = download: http://hg.netbeans.org/binaries/" + nl;

                }

                // XXX should also register hooks.pretxncommit.crlf=python:hgext.win32text.forbidcrlf (for Hg 1.0+ only)

                OutputStream os = new FileOutputStream(hgrc);

                try {

                    os.write(config.getBytes());

                } finally {

                    os.close();

                }

            } catch (IOException x) {

                throw new BuildException(x, getLocation());

            }

            try {

                log("Looking for external binaries in " + repo + " which need to be checked out again using decoder");

                List<String> commandAndArgs = new ArrayList<String>(hgExecutable);

                commandAndArgs.add("locate");

                commandAndArgs.add(BINARIES);

                Process p = new ProcessBuilder(commandAndArgs).directory(repo).start();

                BufferedReader r = new BufferedReader(new InputStreamReader(p.getInputStream()));

                boolean doCheckout = false;

                String binary;

                while ((binary = r.readLine()) != null) {

                    File f = new File(repo, binary);

                    log("Examining: " + f, Project.MSG_DEBUG);

                    if (!f.isFile()) {

                        log("No such file checked out: " + f, Project.MSG_VERBOSE);

                        doCheckout = true; // in case raw files got deleted last time

                        continue;

                    }

                    byte[] rawheader = "<<<EXTERNAL ".getBytes();

                    byte[] buf = new byte[rawheader.length];

                    InputStream is = new FileInputStream(f);

                    try {

                        is.read(buf);

                    } finally {

                        is.close();

                    }

                    if (Arrays.equals(buf, rawheader)) {

                        if (!f.delete()) {

                            throw new IOException("Failed to delete " + f);

                        }

                        doCheckout = true;

                    } else {

                        log("Does not look like a raw file: " + f, Project.MSG_VERBOSE);

                    }

                }

                if (doCheckout) {

                    log("Will check out external binaries fresh");

                    log("(This could take a while as binaries are downloaded into your cache.)");

                    HgExec x = new HgExec();

                    x.setProject(getProject());

                    x.createArg().setValue("checkout");

                    x.setDir(repo);

                    x.setFailonerror(true);

                    x.init();

                    x.setLocation(getLocation());

                    x.execute();

                }

            } catch (IOException x) {

                throw new BuildException(x + "; failed to run:\n" +

                        "hg -R " + repo + " locate \"" + BINARIES + "\"\n" +

                        "Please run this yourself, delete any matching files, then run:\n" +

                        "hg -R " + repo + " checkout\n" +

                        "and restart the build.", getLocation());

            }

        }

    }

}

/*

Sample upload script (edit repository location as needed):

#!/usr/bin/env ruby

repository = '/tmp/repository'

require 'cgi'

require 'digest/sha1'

require 'date'

cgi = CGI.new

begin

  if cgi.request_method == 'POST'

    value = cgi['file']

    content = value.read

    name = value.original_filename.gsub(/\.\.|[^a-zA-Z0-9._+-]/, '_')

    sha1 = Digest::SHA1.hexdigest(content).upcase

    open("#{repository}/#{sha1}-#{name}", "w") do |f|

      f.write content

    end

    open("#{repository}/log", "a") do |f|

      f << "#{DateTime.now.to_s} #{sha1}-#{name} #{cgi.remote_user}\n"

    end

    cgi.out do <<RESPONSE

<html>

<head>

<title>Uploaded #{name}</title>

</head>

<body>

<p>Uploaded as:</p>

<pre>#{sha1} #{name}</pre>

</body>

</html>

RESPONSE

    end

  else

    cgi.out do <<FORM

<html>

<head>

<title>Upload a Binary</title>

</head>

<body>

<form method="POST" action="" enctype="multipart/form-data">

<input type="file" name="file">

<input type="submit" value="Upload">

</form>

</body>

</html>

FORM

    end

  end

rescue

  cgi.out do

    "Caught an exception: #{$!}"

  end

end

 */

import os, re, urllib2, sha, inspect, sys

from mercurial import util, httprepo, ui

if sys.version_info < (2, 4, 4):

    ui.ui().warn('Warning: external hook requires Python 2.4.4+ (2.5.1 preferred)\n')

# Workaround for a Python bug (in linecache.py?):

# http://bugs.python.org/issue1728

# http://bugs.python.org/issue1665

# https://bugs.launchpad.net/ubuntu/+source/python-defaults/+bug/70902

# http://mail.python.org/pipermail/python-bugs-list/2007-March/037472.html

_inspect_findsource_orig = inspect.findsource

def _inspect_findsource_robust(object):

    try:

        return _inspect_findsource_orig(object)

    except IndexError:

        raise IOError('workaround for linecache bug')

inspect.findsource=_inspect_findsource_robust

# Compatibility for Hg not including f8ad3b76e923:

def _findparamvalue(function, param):

    for framerec in inspect.getouterframes(inspect.currentframe()):

        if framerec[3] == function:

            funcvars = inspect.getargvalues(framerec[0])[3]

            if not param in funcvars:

                raise util.Abort('No parameter named %s in function %s' % (param, function))

            return funcvars[param]

    raise util.Abort('No function named %s in stack' % function)

def _filename(f):

    if f:

        return f

    return _findparamvalue('_filter', 'filename')

def _ui(u):

    if u:

        return u

    return _findparamvalue('_filter', 'self').ui

def _repo(r):

    if r:

        return r

    return _findparamvalue('_filter', 'self')

def _trim(filename):

    return os.path.basename(filename)

def _cachedir():

    if 'HGEXTERNALCACHE' in os.environ:

        d = os.environ['HGEXTERNALCACHE']

    else:

        d = os.path.expanduser('~/.hgexternalcache')

    if not os.path.exists(d):

        os.makedirs(d)

    return d

def _sha1hash(data):

    return sha.new(data).hexdigest().upper()

def _download_to_cache(url, ui, sha1, filename, cachefile):

    ui.status('Downloading %s\n' % url)

    handle = urllib2.urlopen(url)

    data = handle.read()

    handle.close()

    if sha1 != _sha1hash(data):

        raise util.Abort('hash mismatch in %s' % filename)

    # XXX acquire write lock, or write to temp file and do atomic rename

    handle = open(cachefile, 'wb')

    handle.write(data)

    handle.close()

    return data

def download(s, cmd, ui=None, filename=None, **kwargs):

    # To support dev versions of Hg with f8ad3b76e923 but not f3a8b5360100:

    cmd = re.sub(r'^download: *', '', cmd)

    filename = _filename(filename)

    ui = _ui(ui)

    n = _trim(filename)

    m = re.match(r'^<<<EXTERNAL (([0-9A-F]{40})-([a-zA-Z0-9._+-]+))>>>\n$', s)

    if not m:

        raise util.Abort('malformed contents in %s' % filename)

    if n != m.group(3):

        raise util.Abort('incorrect basename in %s: %s' % (filename, m.group(3)))

    cachefile = os.path.join(_cachedir(), m.group(1))

    if os.path.exists(cachefile):

        handle = open(cachefile, 'rb')

        data = handle.read()

        handle.close()

        if m.group(2) != _sha1hash(data):

            try:

                os.remove(cachefile)

            except:

                pass

            raise util.Abort('hash mismatch in %s' % filename)

    else:

        data = _download_to_cache(url = cmd + m.group(1),

                                  ui = ui,

                                  sha1 = m.group(2),

                                  filename = filename,

                                  cachefile = cachefile)

    return data

def upload(s, cmd, ui=None, repo=None, filename=None, **kwargs):

    cmd = re.sub(r'^upload: *', '', cmd)

    filename = _filename(filename)

    ui = _ui(ui)

    repo = _repo(repo)

    n = _trim(filename)

    if not re.match(r'[a-zA-Z0-9._+-]+', n):

        raise util.Abort('unsupported file basename: %s', filename)

    sha1 = _sha1hash(s)

    full = '%s-%s' % (sha1, n)

    cachefile = os.path.join(_cachedir(), full)

    if not os.path.exists(cachefile):

        # XXX forces download and upload URLs to be related;

        # would be better to get download URL from download filter,

        # but that info is not trivially accessible here:

        m = re.match(r'(https?://)(([^:@]+)(:([^@]+))?@)?(.+)upload', cmd)

        if not m:

            raise util.Abort('malformed upload URL: %s' % cmd)

        downloadurl = m.group(1) + m.group(6) + full

        url = m.group(1) + m.group(6) + 'upload'

        try:

            _download_to_cache(url = downloadurl,

                               ui = ui,

                               sha1 = sha1,

                               filename = filename,

                               cachefile = cachefile)

            ui.status('No need to upload %s: %s already exists\n' % (filename, downloadurl))

        except IOError:

            # probably a 404, this is normal

            pm = httprepo.passwordmgr(ui)

            pm.add_password(None, url, m.group(3), m.group(5))

            ui.status('Uploading %s to %s (%s Kb)\n' % (filename, url, len(s) / 1024))

            auth = urllib2.HTTPBasicAuthHandler(pm)

            try:

                data = {'file': repo.wfile(filename)}

                # XXX support proxies; look at httprepo.httprepository.__init__

                # or http://www.hackorama.com/python/upload.shtml

                urllib2.build_opener(MultipartPostHandler, auth).open(url, data).close()

            except IOError, err:

                raise util.Abort('Problem uploading %s to %s (try it manually using a web browser): %s\n' % (filename, url, err))

            # Now ensure that the upload actually worked, by downloading:

            _download_to_cache(url = downloadurl,

                               ui = ui,

                               sha1 = sha1,

                               filename = filename,

                               cachefile = cachefile)

    return '<<<EXTERNAL %s>>>\n' % full

def reposetup(ui, repo):

    if not repo.local():

        return

    for name, fn in {'download:': download, 'upload:': upload}.iteritems():

        try:

            # Hg 0.9.6+ (with f8ad3b76e923):

            repo.adddatafilter(name, fn)

        except AttributeError:

            # Hg 0.9.5:

            util.filtertable[name] = fn

# --- FROM http://odin.himinbi.org/MultipartPostHandler.py ---

# (with some bug fixes!)

import urllib

import urllib2

import mimetools, mimetypes

import os, stat

class Callable:

    def __init__(self, anycallable):

        self.__call__ = anycallable

# Controls how sequences are uncoded. If true, elements may be given multiple values by

#  assigning a sequence.

doseq = 1

class MultipartPostHandler(urllib2.BaseHandler):

    handler_order = urllib2.HTTPHandler.handler_order - 10 # needs to run first

    def http_request(self, request):

        data = request.get_data()

        if data is not None and type(data) != str:

            v_files = []

            v_vars = []

            for(key, value) in data.items():

                try:

                     value.name

                     v_files.append((key, value))

                except AttributeError:

                     v_vars.append((key, value))

            if len(v_files) == 0:

                data = urllib.urlencode(v_vars, doseq)

            else:

                boundary, data = self.multipart_encode(v_vars, v_files)

                contenttype = 'multipart/form-data; boundary=%s' % boundary

                if(request.has_header('Content-Type')

                   and request.get_header('Content-Type').find('multipart/form-data') != 0):

                    print "Replacing %s with %s" % (request.get_header('content-type'), 'multipart/form-data')

                request.add_unredirected_header('Content-Type', contenttype)

            request.add_data(data)

        return request

    def multipart_encode(vars, files, boundary = None, buffer = None):

        if boundary is None:

            boundary = mimetools.choose_boundary()

        if buffer is None:

            buffer = ''

        for(key, value) in vars:

            buffer += '--%s\r\n' % boundary

            buffer += 'Content-Disposition: form-data; name="%s"' % key

            buffer += '\r\n\r\n' + value + '\r\n'

        for(key, fd) in files:

            filename = os.path.basename(fd.name)

            contenttype = mimetypes.guess_type(filename)[0] or 'application/octet-stream'

            buffer += '--%s\r\n' % boundary

            buffer += 'Content-Disposition: form-data; name="%s"; filename="%s"\r\n' % (key, filename)

            buffer += 'Content-Type: %s\r\n' % contenttype

            fd.seek(0)

            buffer += '\r\n' + fd.read() + '\r\n'

        buffer += '--%s--\r\n\r\n' % boundary

        return boundary, buffer

    multipart_encode = Callable(multipart_encode)

    https_request = http_request

# ------------------------------------------------------------