+import com.fasterxml.jackson.databind.node.ObjectNode;

+import org.eclipse.jgit.api.ArchiveCommand;

+import org.eclipse.jgit.api.Git;

+import org.eclipse.jgit.archive.ZipFormat;

+import play.mvc.Controller;

+import play.mvc.Http;

+import play.mvc.Result;

+import play.mvc.With;

+import playRepository.GitRepository;

+    public static Result download(String userName, String projectName, String branch, String path)

+            throws UnsupportedOperationException, IOException, SVNException, GitAPIException, ServletException {

+        Project project = Project.findByOwnerAndProjectName(userName, projectName);

+

+        if (!RepositoryService.VCS_GIT.equals(project.vcs) && !RepositoryService.VCS_SUBVERSION.equals(project.vcs)) {

+            return status(Http.Status.NOT_IMPLEMENTED, project.vcs + " is not supported!");

+        }

+

+        final String targetBranch = HttpUtil.decodePathSegment(branch);

+        final String targetPath = HttpUtil.decodePathSegment(path);

+

+        PlayRepository repository = RepositoryService.getRepository(project);

+        List<ObjectNode> recursiveData = RepositoryService.getMetaDataFromAncestorDirectories(

+                repository, targetBranch, targetPath);

+

+        if (recursiveData == null) {

+            return notFound(ErrorViews.NotFound.render());

+        }

+

+        // Prepare a chunked text stream

+        Chunks<byte[]> chunks = new ByteChunks() {

+            // Called when the stream is ready

+            public void onReady(Chunks.Out<byte[]> out) {

+                repository.getArchive(out, targetBranch);

+            }

+        };

+

+        response().setHeader("Content-Disposition", "attachment; filename=" + projectName + "-" + branch + ".zip");

+        return ok(chunks);

+    }

+

+    @With(DefaultProjectCheckAction.class)

+import com.fasterxml.jackson.databind.JsonNode;

+import com.fasterxml.jackson.databind.node.ObjectNode;

+import org.eclipse.jgit.api.ArchiveCommand;

+import org.eclipse.jgit.archive.ZipFormat;

+import org.eclipse.jgit.errors.AmbiguousObjectException;

+import org.eclipse.jgit.errors.IncorrectObjectTypeException;

+import play.mvc.Results.Chunks;

+import utils.ChunkedOutputStream;

+

+    public void getArchive(Chunks.Out<byte[]> out, String branchName){

+        Git git = new Git(getRepository());

+        ArchiveCommand.registerFormat("zip", new ZipFormat());

+        try {

+            ChunkedOutputStream cos = new ChunkedOutputStream(out, 16384);

+            git.archive()

+                    .setTree(getRepository().resolve(branchName))

+                    .setFormat("zip")

+                    .setOutputStream(cos)

+                    .call();

+        } catch (IncorrectObjectTypeException | AmbiguousObjectException | GitAPIException e) {

+            play.Logger.error(e.getMessage());

+        } catch (IOException e){

+            play.Logger.error(e.getMessage());

+        } finally{

+            ArchiveCommand.unregisterFormat("zip");

+        }

+    }

+import play.mvc.Results.Chunks;

+

+    public void getArchive(Chunks.Out<byte[]> out, String branchName);

+import play.mvc.Results;

+    @Override

+    public void getArchive(Results.Chunks.Out<byte[]> out, String branchName) {

+

+    }

+

+/**

+ *  Yona, 21st Century Project Hosting SW

+ *  <p>

+ *  Copyright Yona & Yobi Authors & NAVER Corp.

+ *  https://yona.io

+ **/

+

+package utils;

+

+import play.mvc.Results.Chunks;

+

+import java.io.IOException;

+import java.io.OutputStream;

+

+//

+// ChunkedOutputStream is made by referring to BufferedOutputStream.java

+//

+public class ChunkedOutputStream extends OutputStream {

+

+    Chunks.Out<byte[]> out;

+    /**

+     * The internal buffer where data is stored.

+     */

+    protected byte buf[];

+

+    /**

+     * The number of valid bytes in the buffer. This value is always

+     * in the range <tt>0</tt> through <tt>buf.length</tt>; elements

+     * <tt>buf[0]</tt> through <tt>buf[count-1]</tt> contain valid

+     * byte data.

+     */

+    protected int count;

+

+    public ChunkedOutputStream(Chunks.Out<byte[]> out, int size) {

+        if (size <= 0) {

+            buf = new byte[16384];

+        } else {

+            buf = new byte[size];

+        }

+        this.out = out;

+    }

+

+    /**

+     * Writes the specified byte to this buffered output stream.

+     *

+     * @param      b   the byte to be written.

+     * @exception  IOException  if an I/O error occurs.

+     */

+    @Override

+    public synchronized void write(int b) throws IOException {

+        if (count >= buf.length) {

+            flushBuffer();

+        }

+        buf[count++] = (byte)b;

+    }

+

+    public void write(byte b[]) throws IOException {

+        throw new UnsupportedOperationException("write(byte b[])");

+    }

+

+    /**

+     * Writes <code>len</code> bytes from the specified byte array

+     * starting at offset <code>off</code> to this buffered output stream.

+     *

+     * <p> Ordinarily this method stores bytes from the given array into this

+     * stream's buffer, flushing the buffer to the underlying output stream as

+     * needed.  If the requested length is at least as large as this stream's

+     * buffer, however, then this method will flush the buffer and write the

+     * bytes directly to the underlying output stream.  Thus redundant

+     * <code>BufferedOutputStream</code>s will not copy data unnecessarily.

+     *

+     * @param      b     the data.

+     * @param      off   the start offset in the data.

+     * @param      len   the number of bytes to write.

+     * @exception  IOException  if an I/O error occurs.

+     */

+    @Override

+    public synchronized void write(byte b[], int off, int len) throws IOException {

+        if (len >= buf.length) {

+            /* If the request length exceeds the size of the output buffer,

+               flush the output buffer and then write the data directly.

+               In this way buffered streams will cascade harmlessly. */

+            flushBuffer();

+            write(b, off, len);

+            return;

+        }

+        if (len > buf.length - count) {

+            flushBuffer();

+        }

+        System.arraycopy(b, off, buf, count, len);

+        count += len;

+    }

+

+    private void flushBuffer() throws IOException {

+        if (count > 0) {

+            chunkOut();

+        }

+    }

+

+    @Override

+    public void close() throws IOException {

+        if (count > 0) {

+            chunkOut();

+        }

+        out.close();

+    }

+

+    private void chunkOut() {

+        byte remainBuf[] = new byte[count];

+        System.arraycopy(buf, 0, remainBuf,0, count);

+        out.write(remainBuf);

+        count = 0;

+    }

+}

+                @if(project.isGit) {

+                <div class="pull-right">

+                    <a href="@routes.CodeApp.download(project.owner, project.name, URLEncoder.encode(branch, "UTF-8"))" class="ybtn">

+                        @Messages("code.download")</a>

+                </div>

+                }

+  // JGit Archive Formats

+  "org.eclipse.jgit" % "org.eclipse.jgit.archive" % "4.5.0.201609210915-r",

+code.download = Download as .zip file

+code.download = 압축 파일로 내려받기

+GET            /:user/:project/code/:branch/download                                  controllers.CodeApp.download(user, project, branch:String, path="")