play run

sys.path.append(os.path.join(os.path.dirname(os.path.realpath(sys.argv[0])), 'framework', 'pym'))

from play.cmdloader import CommandLoader
from play.application import PlayApplication
from play.utils import *

play_env["id_file"] = os.path.join(play_env['basedir'], 'id')
if os.path.exists(play_env["id_file"]):
    play_env["id"] = open(play_env["id_file"]).readline().strip()
else:
    play_env["id"] = ''

application_path = None
remaining_args = []
if len(sys.argv) == 1:
    application_path = os.getcwd()
if len(sys.argv) == 2:
    application_path = os.getcwd()
    remaining_args = sys.argv[2:]
if len(sys.argv) > 2:
    if sys.argv[2].startswith('-'):
        application_path = os.getcwd()
        remaining_args = sys.argv[2:]
    else:
        application_path = os.path.normpath(os.path.abspath(sys.argv[2]))
        remaining_args = sys.argv[3:]

ignoreMissing = False
if remaining_args.count('--force') == 1:
    remaining_args.remove('--force')
    ignoreMissing = True

DEFAULTS = {
    'http.port': '9000',
    'jpda.port': '8000'
}

#env为命令参数
if env.has_key('http.port'):
    self.entries['http.port'] = env['http.port']

if remaining_args.count('--deps') == 1:
    cmdloader.commands['dependencies'].execute(command='dependencies', app=play_app, args=['--sync'], env=play_env, cmdloader=cmdloader)
    remaining_args.remove('--deps')

if play_command in cmdloader.commands:
    for name in cmdloader.modules:
        module = cmdloader.modules[name]
        if 'before' in dir(module):
            module.before(command=play_command, app=play_app, args=remaining_args, env=play_env)
    status = cmdloader.commands[play_command].execute(command=play_command, app=play_app, args=remaining_args, env=play_env, cmdloader=cmdloader)
    for name in cmdloader.modules:
        module = cmdloader.modules[name]
        if 'after' in dir(module):
            module.after(command=play_command, app=play_app, args=remaining_args, env=play_env)
    sys.exit(status)

def run(app, args):
    #app即为play脚本中创建的PlayApplication类
    global process
    #这里检查是否存在conf/routes和conf/application.conf
    app.check()

    print "~ Ctrl+C to stop"
    print "~ "
    java_cmd = app.java_cmd(args)
    try:
        process = subprocess.Popen (java_cmd, env=os.environ)
        signal.signal(signal.SIGTERM, handle_sigterm)
        return_code = process.wait()
    signal.signal(signal.SIGINT, handle_sigint)
        if 0 != return_code:
            sys.exit(return_code)
    except OSError:
        print "Could not execute the java executable, please make sure the JAVA_HOME environment variable is set properly (the java executable should reside at JAVA_HOME/bin/java). "
        sys.exit(-1)
    print

def java_cmd(self, java_args, cp_args=None, className='play.server.Server', args = None):
    if args is None:
        args = ['']
    memory_in_args=False

    #检查java参数中是否有jvm内存设置
    for arg in java_args:
        if arg.startswith('-Xm'):
            memory_in_args=True
    #如果参数中无jvm内存设置，那么在配置文件中找是否有jvm内存设置，若还是没有则在环境变量中找是否有JAVA_OPTS
    #这里其实有个问题，这里假定的是JAVA_OPTS变量里只存了jvm内存设置，如果JAVA_OPTS还存了其他选项，那对运行可能有影响
    if not memory_in_args:
        memory = self.readConf('jvm.memory')
        if memory:
            java_args = java_args + memory.split(' ')
        elif 'JAVA_OPTS' in os.environ:
            java_args = java_args + os.environ['JAVA_OPTS'].split(' ')
    #获取程序的classpath
    if cp_args is None:
        cp_args = self.cp_args()
    #读取配置文件中的jpda端口
    self.jpda_port = self.readConf('jpda.port')
    #读取配置文件中的运行模式
    application_mode = self.readConf('application.mode').lower()
    #如果模式是prod，则用server模式编译
    if application_mode == 'prod':
        java_args.append('-server')
    # JDK 7 compat
    # 使用新class校验器 (不知道作用)
    java_args.append('-XX:-UseSplitVerifier')
    #查找配置文件中是否有java安全配置，如果有则加入java参数中
    java_policy = self.readConf('java.policy')
    if java_policy != '':
        policyFile = os.path.join(self.path, 'conf', java_policy)
        if os.path.exists(policyFile):
            print "~ using policy file \"%s\"" % policyFile
            java_args.append('-Djava.security.manager')
            java_args.append('-Djava.security.policy==%s' % policyFile)
    #加入http端口设置
    if self.play_env.has_key('http.port'):
        args += ["--http.port=%s" % self.play_env['http.port']]
    #加入https端口设置
    if self.play_env.has_key('https.port'):
        args += ["--https.port=%s" % self.play_env['https.port']]

    #设置文件编码
    java_args.append('-Dfile.encoding=utf-8')
    #设置编译命令 (这边使用了jregex/Pretokenizer类的next方法，不知道有什么用)
    java_args.append('-XX:CompileCommand=exclude,jregex/Pretokenizer,next')

    #如果程序模式在dev，则添加jpda调试器参数
    if self.readConf('application.mode').lower() == 'dev':
        if not self.play_env["disable_check_jpda"]: self.check_jpda()
        java_args.append('-Xdebug')
        java_args.append('-Xrunjdwp:transport=dt_socket,address=%s,server=y,suspend=n' % self.jpda_port)
        java_args.append('-Dplay.debug=yes')
    #拼接java参数
    java_cmd = [self.java_path(), '-javaagent:%s' % self.agent_path()] + java_args + ['-classpath', cp_args, '-Dapplication.path=%s' % self.path, '-Dplay.id=%s' % self.play_env["id"], className] + args
    return java_cmd

try:
    #这里启动程序
    play_process = subprocess.Popen(java_cmd, env=os.environ, stdout=sout)
    except OSError:
        print "Could not execute the java executable, please make sure the JAVA_HOME environment variable is set properly (the java executable should reside at JAVA_HOME/bin/java). "
        sys.exit(-1)
    #打开日志输出文件
    soutint = open(os.path.join(app.log_path(), 'system.out'), 'r')
    while True:
        if play_process.poll():
            print "~"
            print "~ Oops, application has not started?"
            print "~"
            sys.exit(-1)
        line = soutint.readline().strip()
        if line:
            print line
            #若出现'Server is up and running'则正常启动
            if line.find('Server is up and running') > -1: # This line is written out by Server.java to system.out and is not log file dependent
                soutint.close()
                break

print "~ The new application will be created in %s" % os.path.normpath(app.path)
if application_name is None:
    application_name = raw_input("~ What is the application name? [%s] " % os.path.basename(app.path))
if application_name == "":
    application_name = os.path.basename(app.path)
copy_directory(os.path.join(env["basedir"], 'resources/application-skel'), app.path)
os.mkdir(os.path.join(app.path, 'app/models'))
os.mkdir(os.path.join(app.path, 'lib'))
app.check()
replaceAll(os.path.join(app.path, 'conf/application.conf'), r'%APPLICATION_NAME%', application_name)
replaceAll(os.path.join(app.path, 'conf/application.conf'), r'%SECRET_KEY%', secretKey())
print "~"

static boolean preCompile() {
    if (usePrecompiled) {
        if (Play.getFile("precompiled").exists()) {
            classloader.getAllClasses();
            Logger.info("Application is precompiled");
            return true;
        }
        Logger.error("Precompiled classes are missing!!");
        fatalServerErrorOccurred();
        return false;
    }
    //这里开始预编译
    try {
        Logger.info("Precompiling ...");
        Thread.currentThread().setContextClassLoader(Play.classloader);
        long start = System.currentTimeMillis();
        //getAllClasses方法较长，就不贴了，下面一段代码在getAllClasses方法中进入
        classloader.getAllClasses();

        if (Logger.isTraceEnabled()) {
            Logger.trace("%sms to precompile the Java stuff", System.currentTimeMillis() - start);
        }

        if (!lazyLoadTemplates) {
            start = System.currentTimeMillis();
            //编译模板
            TemplateLoader.getAllTemplate();

            if (Logger.isTraceEnabled()) {
                Logger.trace("%sms to precompile the templates", System.currentTimeMillis() - start);
            }
        }
        return true;
    } catch (Throwable e) {
        Logger.error(e, "Cannot start in PROD mode with errors");
        fatalServerErrorOccurred();
        return false;
    }
}

public byte[] enhance() {
    this.enhancedByteCode = this.javaByteCode;
    if (isClass()) {

        // before we can start enhancing this class we must make sure it is not a PlayPlugin.
        // PlayPlugins can be included as regular java files in a Play-application.
        // If a PlayPlugin is present in the application, it is loaded when other plugins are loaded.
        // All plugins must be loaded before we can start enhancing.
        // This is a problem when loading PlayPlugins bundled as regular app-class since it uses the same classloader
        // as the other (soon to be) enhanched play-app-classes.
        boolean shouldEnhance = true;
        try {
            CtClass ctClass = enhanceChecker_classPool.makeClass(new ByteArrayInputStream(this.enhancedByteCode));
            if (ctClass.subclassOf(ctPlayPluginClass)) {
                shouldEnhance = false;
            }
        } catch( Exception e) {
            // nop
        }

        if (shouldEnhance) {
            Play.pluginCollection.enhance(this);
        }
    }

    //主要是这一段，他将增强处理后的字节码写入了文件，增强处理在之后会深入展开
    if (System.getProperty("precompile") != null) {
        try {
            // emit bytecode to standard class layout as well
            File f = Play.getFile("precompiled/java/" + (name.replace(".", "/")) + ".class");
            f.getParentFile().mkdirs();
            FileOutputStream fos = new FileOutputStream(f);
            fos.write(this.enhancedByteCode);
            fos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return this.enhancedByteCode;
}