JDK version 7(1.7) is required.

 or

 or using web browser (for windows)

 ### Unzip

 ### Change directory to unzipped directory

 ### Download Yobi

 **Caution! in case2, You might come across troubles when you try to upgrade Yobi.**

 ### Change directory to cloned Yobi directory (or cd to your unzipped file directory)

     cd yobi

 or (for windows)

 Required files will be download automatically. In the first time, it may take about 10 min or more.

 Also, you can configure start options.

 If your system's memory is over than 4G, we recommend to use follow options.

 ### Connect with browser

 If you want to change port, check your permission to use 80 port

 ### Upgrade Yobi

 JDK 7(1.7)이어야 합니다.

 혹은

 웹 브라우저에서 (이를테면, MS윈도우즈 사용자일 경우)

 ### 압축풀기

 ### 압축을 푼 다음 하위 디렉터리로 이동

 ### Yobi 소스 내려 받기

 주의! case2의 경우, 업그레이드를 할 때 문제가 생길 수 있습니다.

 ### clone 받은 Yobi 디렉터리로 이동 

 (혹은 압축을 해제한 디렉터리로 이동)

     cd yobi

 혹은 (윈도우 사용자일 경우)

 실행하면 필요한 파일들을 web에서 내려받습니다. 첫 실행시 네트워크 상황에 따라 10여분 가까이 소요될 수 있습니다.

 시작 옵션은 조정가능합니다. 만약 시스템 메모리가 4기가 이상이라면

 아래 옵션으로 실행하는걸 권장합니다.

 ### 브라우저로 접속

     http://127.0.0.1:9000

 80 포트 등으로 포트를 변경하고 싶을 경우에는 해당 포트가 사용가능한지 확인 한 다음 80 포트를 사용할 수 있는 계정으로 실행합니다.

 ### 업그레이드 하기

 import play.data.Form;

 import play.mvc.*;

 import play.mvc.Http.RequestHeader;

 import play.libs.F.Promise;

 import utils.AccessControl;

     private Action<Void> getDefaultAction(final Http.Request request) {

         final long start = System.currentTimeMillis();

         return new Action.Simple() {

                 UserApp.initTokenUser();

                 UserApp.updatePreferredLanguage();

                 ctx.response().setHeader("Date", DateUtils.formatDate(new Date()));

                 ctx.response().setHeader("Cache-Control", "no-cache");

                 AccessLogger.log(request, promise, start);

                 return promise;

             }

     private Action<Void> getRestartAction() {

         return new Action.Simple() {

             @Override

             }

         };

     }

     private Action<Void> getConfigSecretAction() {

         return new Action.Simple() {

             @Override

                 if( ctx.request().method().toLowerCase().equals("post") ) {

                     Form<User> newSiteAdminUserForm = form(User.class).bindFromRequest();

                     if (hasError(newSiteAdminUserForm)) {

                     }

                     User siteAdmin = SiteAdmin.updateDefaultSiteAdmin(newSiteAdminUserForm.get());

                     replaceSiteSecretKey(createSeed(siteAdmin.password));

                     isRestartRequired = true;

                 } else {

                 }

             }

     }

     @Override

         AccessLogger.log(request, null, Http.Status.NOT_FOUND);

     }

     @Override

         AccessLogger.log(request, null, Http.Status.INTERNAL_SERVER_ERROR);

         if (Play.isProd()) {

         } else {

             return super.onError(request, t);

         }

     }

     @Override

         AccessLogger.log(request, null, Http.Status.BAD_REQUEST);

     }

 }

 import play.mvc.Action;

 import play.mvc.Http.Context;

 import play.mvc.Result;

 import play.libs.F.Promise;

 import utils.AccessControl;

 import utils.AccessLogger;

  */

 public abstract class AbstractProjectCheckAction<T> extends Action<T> {

     @Override

         PathParser parser = new PathParser(context);

         String ownerLoginId = parser.getOwnerLoginId();

         String projectName = parser.getProjectName();

         Project project = Project.findByOwnerAndProjectName(ownerLoginId, projectName);

         if (project == null) {

             if (UserApp.currentUser() == User.anonymous){

                 flash("failed", Messages.get("error.auth.unauthorized.waringMessage"));

             } else {

             }

             AccessLogger.log(context.request(), promise, null);

         if (!AccessControl.isAllowed(UserApp.currentUser(), project.asResource(), Operation.READ)) {

             flash("failed", Messages.get("error.auth.unauthorized.waringMessage"));

             AccessLogger.log(context.request(), promise, null);

             return promise;

         }

         return call(project, context, parser);

     }

             throws Throwable;

 }

 import play.mvc.Action;

 import play.mvc.Http.Context;

 import play.mvc.Result;

 import play.libs.F.Promise;

 import utils.AccessControl;

 import utils.AccessLogger;

 public class AnonymousCheckAction extends Action<AnonymousCheck> {

     @Override

         if ((AccessControl.isAnonymousNotAllowed() || configuration.requiresLogin()) &&

                 UserApp.currentUser().isAnonymous()) {

             if (configuration.displaysFlashMessage()) {

             }

             String loginFormUrl = routes.UserApp.loginForm().url();

             loginFormUrl += "?redirectUrl=" + context.request().path();

             AccessLogger.log(context.request(), promise, null);

             return promise;

         }

 import models.Project;

 import play.mvc.Http.Context;

 import play.mvc.Result;

 import play.libs.F.Promise;

 /**

  */

 public class DefaultProjectCheckAction extends AbstractProjectCheckAction<Void> {

     @Override

         return this.delegate.call(context);

     }

 }

 import models.resource.ResourceConvertible;

 import play.mvc.Http.Context;

 import play.mvc.Result;

 import play.libs.F.Promise;

 import utils.AccessControl;

 import utils.AccessLogger;

  */

 public class IsAllowedAction extends AbstractProjectCheckAction<IsAllowed> {

     @Override

         ResourceType resourceType = this.configuration.resourceType();

         ResourceConvertible resourceObject = Resource.getResourceObject(parser, project, resourceType);

         Operation operation = this.configuration.value();

         if(resourceObject == null) {

             AccessLogger.log(context.request(), promise, null);

             return promise;

         }

         if(!AccessControl.isAllowed(UserApp.currentUser(), resourceObject.asResource(), operation)) {

             AccessLogger.log(context.request(), promise, null);

             return promise;

         }

 import models.User;

 import play.mvc.Http.Context;

 import play.mvc.Result;

 import play.libs.F.Promise;

 import utils.AccessControl;

 import utils.AccessLogger;

  */

 public class IsCreatableAction extends AbstractProjectCheckAction<IsCreatable> {

     @Override

         User currentUser = UserApp.currentUser();

         if (!AccessControl.isProjectResourceCreatable(currentUser, project, this.configuration.value())) {

             AccessLogger.log(context.request(), promise, null);

             return promise;

         }

 import models.Project;

 import play.mvc.Http.Context;

 import play.mvc.Result;

 import play.libs.F.Promise;

 import utils.AccessLogger;

 import utils.ErrorViews;

  */

 public class IsOnlyGitAvailableAction extends AbstractProjectCheckAction<IsOnlyGitAvailable> {

     @Override

         if(!project.isGit()) {

             AccessLogger.log(context.request(), promise, null);

             return promise;

         }

 import play.mvc.Action;

 import play.mvc.Http;

 import play.mvc.Result;

 import play.libs.F.Promise;

 import utils.AccessLogger;

 import utils.ErrorViews;

 public class NullProjectCheckAction extends Action<Void> {

     @Override

         PathParser parser = new PathParser(context);

         String ownerLoginId = parser.getOwnerLoginId();

         String projectName = parser.getProjectName();

         Project project = Project.findByOwnerAndProjectName(ownerLoginId, projectName);

         if (project == null) {

             if (UserApp.currentUser() == User.anonymous){

                 flash("failed", Messages.get("error.auth.unauthorized.waringMessage"));

             } else {

             }

             AccessLogger.log(context.request(), promise, null);

 import org.apache.commons.lang3.StringUtils;

 import org.apache.tika.Tika;

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

 import play.data.Form;

 import play.data.validation.ValidationError;

 import play.db.ebean.Transactional;

 import play.libs.Json;

 import play.mvc.Controller;

 import play.mvc.Result;

 import playRepository.GitBranch;

 import playRepository.GitRepository;

 import playRepository.RepositoryService;

 import play.db.ebean.Model;

 import play.libs.Akka;

 import scala.concurrent.duration.Duration;

 import utils.FileUtil;

 import utils.JodaDateUtil;

 import play.libs.F.Callback;

 import play.libs.F.Promise;

 import play.mvc.Http;

 import java.text.SimpleDateFormat;

 import java.util.Date;

      * @see <a href="http://httpd.apache.org/docs/2.2/en/logs.html#combined">Combined Log Format - Apache HTTP Server</a>

      * @see <a href="http://httpd.apache.org/docs/2.2/mod/mod_log_config.html#formats">Custom Log Formats - Apache HTTP Server</a>

      */

             final Long startTimeMillis) {

         final String username = UserApp.currentUser().loginId;

             @Override

                         startTimeMillis);

             }

         });

 import play.mvc.Http.Request;

 import play.mvc.Http.Response;

 import play.mvc.Result;

 import play.libs.F.Promise;

 import java.io.UnsupportedEncodingException;

     }

     @Override

         User user;

         try {

             user = authenticate(context.request());

         } catch (MalformedCredentialsException error) {

             AccessLogger.log(context.request(), promise, null);

             return promise;

         } catch (UnsupportedEncodingException e) {

             AccessLogger.log(context.request(), promise, null);

             return promise;

         }

 import models.Organization;

 import models.Project;

 import models.User;

 import views.html.index.index;

         throw new UnsupportedOperationException();

     }

 }

         return Integer.parseInt(contentLength);

     }

     @Override

     public String getContentType() {

         return request.getHeader(Http.HeaderNames.CONTENT_TYPE);

             protected void finalize() throws Throwable {

                 close();

                 super.finalize();

             }

         };

     }

         throw new UnsupportedOperationException();

     }

 }

             target.close();

             super.close();

         }

     }

     public PlayServletResponse(Response response) throws IOException {

     @Override

     public void setContentLength(int length) {

         this.response.setHeader(Http.HeaderNames.CONTENT_LENGTH, Integer.toString(length));

     }

     @Override

         }

         return (encoding.trim());

     }

 }

 import play.mvc.Action;

 import play.mvc.Http.Context;

 import play.mvc.Result;

 import play.libs.F.Promise;

 /**

  */

 public class SiteManagerAuthAction extends Action.Simple {

     @Override

         if (!UserApp.currentUser().isSiteManager()) {

         }

         return delegate.call(context);

     }

 import play.api.i18n.Lang

 import models.CodeCommentThread

 import models.CommentThread

 object TemplateHelper {

     def shortId(commitId: String) = commitId.substring(0, Math.min(7, commitId.size))

     @tailrec

       threads match {

         case head :: tail =>

           head match {

             case (thread: models.NonRangedCodeCommentThread)

             case _ => ;

           }

           renderNonRangedThreads(tail, commitId, html)

     @tailrec

     def _renderEventsOnPullRequest(pull: PullRequest, events: List[PullRequestEvent],

       events match {

         case head :: tail =>

           _renderEventsOnPullRequest(pull, tail, html)

         case _ => html

       }

     def renderEventsOnPullRequest(pull: PullRequest) =

     def urlToCommentThread(thread: CommentThread) = {

         urlToContainer(thread) + "#thread-" + thread.id

 * See the License for the specific language governing permissions and

 * limitations under the License.

 **@

 @import utils.AccessControl._

 @import utils.TemplateHelper._

 @implicitField = @{ helper.FieldConstructor(simpleForm) }

 @readmeUpdateMessage = @{

       "Update README.md"

   }

 }

         @** end of fileUploader **@

         <div class="right-txt mt10 mb10">

           <label class="checkbox">

             <input type="checkbox" id="notice" name="notice">

             @Messages("post.notice.label")

           }

           @if(isProjectResourceCreatable(UserApp.currentUser(), project, ResourceType.COMMIT)){

             <label class="checkbox">

               @Messages("post.readmefy")

             </label>

             }

 * See the License for the specific language governing permissions and

 * limitations under the License.

 **@

 @import utils.AccessControl._

 @import utils.TemplateHelper._

         @** end of fileUploader **@

         <div class="right-txt mt10 mb10">

             @helper.input(form("notice")){(id, name, value, args) =>

             <label class="checkbox">

               <input type="checkbox" id="notice" name="notice" @toHtmlArgs(args) @(if(value.equals(Some("true"))) "checked" else "")/>

 * See the License for the specific language governing permissions and

 * limitations under the License.

 **@