Пример #1
0
def run():
  """ Shuts down Zookeeper. """
  logging.warning("Stopping Zookeeper.")
  monit_interface.stop('zookeeper-9999', is_group=False)
  logging.warning("Done!")

  return True
def run():
    """ Shuts down Zookeeper. """
    logging.warning("Stopping Zookeeper.")
    monit_interface.stop('zookeeper-9999', is_group=False)
    logging.warning("Done!")

    return True
def run():
    """ Shuts down Cassandra. """
    logging.warning("Stopping Cassandra.")
    monit_interface.stop(cassandra_interface.CASSANDRA_MONIT_WATCH_NAME,
                         is_group=False)
    logging.warning("Done!")

    return True
Пример #4
0
def run():
  """ Shuts down Cassandra. """
  logging.warning("Stopping Cassandra.")
  monit_interface.stop(
    cassandra_interface.CASSANDRA_MONIT_WATCH_NAME, is_group=False)
  logging.warning("Done!")

  return True
Пример #5
0
def shutdown_datastore():
    """ Top level function for bringing down Cassandra.

  Returns:
    True on success, False otherwise.
  """
    logging.info("Shutting down Cassandra.")
    monit_interface.stop(cassandra_interface.CASSANDRA_MONIT_WATCH_NAME, is_group=False)
    logging.warning("Done!")
    return True
Пример #6
0
def shutdown_datastore():
    """ Top level function for bringing down Cassandra.

  Returns:
    True on success, False otherwise.
  """
    logging.info("Shutting down Cassandra.")
    monit_interface.stop(cassandra_interface.CASSANDRA_MONIT_WATCH_NAME,
                         is_group=False)
    logging.warning("Done!")
    return True
  def test_stop(self):
    testing.disable_logging()

    flexmock(subprocess)\
      .should_receive('call')\
      .and_return(0) 
    self.assertEqual(True, monit_interface.stop("watch_name"))

    flexmock(subprocess)\
      .should_receive('call')\
      .and_return(1) 
    self.assertEqual(False, monit_interface.stop("watch_name"))
Пример #8
0
    def test_stop(self):
        testing.disable_logging()

        flexmock(subprocess)\
          .should_receive('call')\
          .and_return(0)
        self.assertEqual(True, monit_interface.stop("watch_name"))

        flexmock(subprocess)\
          .should_receive('call')\
          .and_return(1)
        self.assertEqual(False, monit_interface.stop("watch_name"))
Пример #9
0
def stop_app_instance(app_name, port):
  """ Stops a Google App Engine application process instance on current
      machine.

  Args:
    app_name: A string, the name of application to stop.
    port: The port the application is running on.
  Returns:
    True on success, False otherwise.
  """
  if not misc.is_app_name_valid(app_name):
    logging.error("Unable to kill app process %s on port %d because of " \
      "invalid name for application" % (app_name, int(port)))
    return False

  logging.info('Removing routing for {} on port {}'.format(app_name, port))
  remove_routing(app_name, port)

  logging.info("Stopping application %s" % app_name)
  watch = "app___" + app_name + "-" + str(port)
  if not monit_interface.stop(watch, is_group=False):
    logging.error("Unable to stop application server for app {0} on " \
      "port {1}".format(app_name, port))
    return False

  # Now that the AppServer is stopped, remove its monit config file so that
  # monit doesn't pick it up and restart it.
  monit_config_file = '{}/appscale-{}.cfg'.format(MONIT_CONFIG_DIR, watch)
  try:
    os.remove(monit_config_file)
  except OSError as os_error:
    logging.error("Error deleting {0}".format(monit_config_file))

  return True
Пример #10
0
def stop_app(app_name):
  """ Stops all process instances of a Google App Engine application on this
      machine.

  Args:
    app_name: Name of application to stop
  Returns:
    True on success, False otherwise
  """
  if not misc.is_app_name_valid(app_name):
    logging.error("Unable to kill app process %s on because of " \
      "invalid name for application" % (app_name))
    return False

  logging.info("Stopping application %s" % app_name)
  watch = "app___" + app_name
  monit_result = monit_interface.stop(watch)

  if not monit_result:
    logging.error("Unable to shut down monit interface for watch %s" % watch)
    return False

  # Remove the monit config files for the application.
  # TODO: Reload monit to pick up config changes.
  config_files = glob.glob('{}/appscale-{}-*.cfg'.format(MONIT_CONFIG_DIR, watch))
  for config_file in config_files:
    try:
      os.remove(config_file)
    except OSError:
      logging.exception('Error removing {}'.format(config_file))

  return True
Пример #11
0
def stop_app_instance(app_name, port):
  """ Stops a Google App Engine application process instance on current
      machine.

  Args:
    app_name: Name of application to stop
    port: The port the application is running on
  Returns:
    True on success, False otherwise
  """
  if not misc.is_app_name_valid(app_name):
    logging.error("Unable to kill app process %s on port %d because of " +\
                  "invalid name for application"%(app_name, int(port)))
    return False

  logging.info("Stopping application %s"%app_name)
  watch = "app___" + app_name + "-" + str(port)
  if not monit_interface.stop(watch, is_group=False):
    logging.error("Unable to stop application server for app {0} on " \
      "port {1}".format(app_name, port))
    return False

  # Now that the AppServer is stopped, remove its monit config file so that
  # monit doesn't pick it up and restart it.
  monit_config_file = "/etc/monit/conf.d/{0}.cfg".format(watch)
  os.remove(monit_config_file)
  return True
Пример #12
0
def stop_app(app_name):
    """ Stops all process instances of a Google App Engine application on this
      machine.

  Args:
    app_name: Name of application to stop
  Returns:
    True on success, False otherwise
  """
    if not misc.is_app_name_valid(app_name):
        logging.error("Unable to kill app process %s on because of " \
          "invalid name for application" % (app_name))
        return False

    logging.info("Stopping application %s" % app_name)
    watch = "app___" + app_name
    monit_result = monit_interface.stop(watch)

    if not monit_result:
        logging.error("Unable to shut down monit interface for watch %s" %
                      watch)
        return False

    # Remove the monit config files for the application.
    # TODO: Reload monit to pick up config changes.
    config_files = glob.glob('{}/appscale-{}-*.cfg'.format(
        MONIT_CONFIG_DIR, watch))
    for config_file in config_files:
        try:
            os.remove(config_file)
        except OSError:
            logging.exception('Error removing {}'.format(config_file))

    return True
Пример #13
0
  def stop_worker(self, json_request):
    """ Stops the monit watch for queues of an application on the current
        node.
   
    Args:
      json_request: A JSON string with the queue name for which we're 
                    stopping its queues.
    Returns:
      A JSON string with the result.
    """
    request = self.__parse_json_and_validate_tags(json_request,  
                                         self.STOP_WORKERS_TAGS)
    logging.info("Stopping worker: {0}".format(request))
    if 'error' in request:
      return json.dumps(request)

    app_id = request['app_id']
    watch = "celery-" + str(app_id)
    try:
      if monit_interface.stop(watch):
        stop_command = self.get_worker_stop_command(app_id)
        os.system(stop_command) 
        TaskQueueConfig.remove_config_files(app_id)
        result = {'error': False}
      else:
        result = {'error': True, 'reason': "Unable to stop watch %s" % watch}
    except OSError, os_error:
      result = {'error': True, 'reason' : str(os_error)}
Пример #14
0
def stop_app_instance(app_name, port):
    """ Stops a Google App Engine application process instance on current
      machine.

  Args:
    app_name: A string, the name of application to stop.
    port: The port the application is running on.
  Returns:
    True on success, False otherwise.
  """
    if not misc.is_app_name_valid(app_name):
        logging.error("Unable to kill app process %s on port %d because of " \
          "invalid name for application" % (app_name, int(port)))
        return False

    logging.info("Stopping application %s" % app_name)
    watch = "app___" + app_name + "-" + str(port)
    if not monit_interface.stop(watch, is_group=False):
        logging.error("Unable to stop application server for app {0} on " \
          "port {1}".format(app_name, port))
        return False

    # Now that the AppServer is stopped, remove its monit config file so that
    # monit doesn't pick it up and restart it.
    monit_config_file = '{}/appscale-{}.cfg'.format(MONIT_CONFIG_DIR, watch)
    try:
        os.remove(monit_config_file)
    except OSError as os_error:
        logging.error("Error deleting {0}".format(monit_config_file))

    return True
Пример #15
0
def stop_app_instance(app_name, port):
    """ Stops a Google App Engine application process instance on current
      machine.

  Args:
    app_name: Name of application to stop
    port: The port the application is running on
  Returns:
    True on success, False otherwise
  """
    if not misc.is_app_name_valid(app_name):
        logging.error("Unable to kill app process %s on port %d because of " +\
                      "invalid name for application"%(app_name, int(port)))
        return False

    logging.info("Stopping application %s" % app_name)
    watch = "app___" + app_name + "-" + str(port)
    if not monit_interface.stop(watch, is_group=False):
        logging.error("Unable to stop application server for app {0} on " \
          "port {1}".format(app_name, port))
        return False

    # Now that the AppServer is stopped, remove its monit config file so that
    # monit doesn't pick it up and restart it.
    monit_config_file = "/etc/monit/conf.d/{0}.cfg".format(watch)
    os.remove(monit_config_file)
    return True
Пример #16
0
    def stop_worker(self, json_request):
        """ Stops the monit watch for queues of an application on the current
        node.
   
    Args:
      json_request: A JSON string with the queue name for which we're 
                    stopping its queues.
    Returns:
      A JSON string with the result.
    """
        request = self.__parse_json_and_validate_tags(json_request,
                                                      self.STOP_WORKERS_TAGS)
        logging.info("Stopping worker: {0}".format(request))
        if 'error' in request:
            return json.dumps(request)

        app_id = request['app_id']
        watch = "celery-" + str(app_id)
        try:
            if monit_interface.stop(watch):
                stop_command = self.get_worker_stop_command(app_id)
                os.system(stop_command)
                TaskQueueConfig.remove_config_files(app_id)
                result = {'error': False}
            else:
                result = {
                    'error': True,
                    'reason': "Unable to stop watch %s" % watch
                }
        except OSError, os_error:
            result = {'error': True, 'reason': str(os_error)}
Пример #17
0
def stop_service(service_name):
  logging.info("Stopping " + service_name)
  if not monit_interface.stop(service_name):
    logging.error("Monit was unable to stop " + service_name)
    return 1
  else:
    logging.info("Successfully stopped " + service_name)
    return 0
Пример #18
0
def restart_app_instances_for_app(app_name, language):
  """ Restarts all instances of a Google App Engine application on this machine.

  Args:
    app_name: The application ID corresponding to the app to restart.
    language: The language the application is written in.
  Returns:
    True if successful, and False otherwise.
  """
  if not misc.is_app_name_valid(app_name):
    logging.error("Unable to kill app process %s on because of " \
      "invalid name for application" % (app_name))
    return False
  if language == "java":
    remove_conflicting_jars(app_name)
    copy_modified_jars(app_name)
  logging.info("Restarting application %s" % app_name)
  watch = "app___" + app_name
  monit_interface.stop(watch)
  time.sleep(1)
  return monit_interface.start(watch)
Пример #19
0
def stop_app_instance(app_name, port):
  """ Stops a Google App Engine application process instance on current 
      machine.

  Args:
    app_name: Name of application to stop
    port: The port the application is running on
  Returns:
    True on success, False otherwise
  """
  if not misc.is_app_name_valid(app_name):
    logging.error("Unable to kill app process %s on port %d because of " +\
                  "invalid name for application"%(app_name, int(port)))
    return False

  logging.info("Stopping application %s"%app_name)
  watch = "app___" + app_name + "-" + str(port)
  return monit_interface.stop(watch, is_group=False)
Пример #20
0
def stop_app_instance(app_name, port):
    """ Stops a Google App Engine application process instance on current 
      machine.

  Args:
    app_name: Name of application to stop
    port: The port the application is running on
  Returns:
    True on success, False otherwise
  """
    if not misc.is_app_name_valid(app_name):
        logging.error("Unable to kill app process %s on port %d because of " +\
                      "invalid name for application"%(app_name, int(port)))
        return False

    logging.info("Stopping application %s" % app_name)
    watch = "app___" + app_name + "-" + str(port)
    return monit_interface.stop(watch, is_group=False)
Пример #21
0
def stop_app(app_name):
    """ Stops all process instances of a Google App Engine application on this
      machine.

  Args:
    app_name: Name of application to stop
  Returns:
    True on success, False otherwise
  """
    if not misc.is_app_name_valid(app_name):
        logging.error("Unable to kill app process %s on because of " "invalid name for application" % (app_name))
        return False

    logging.info("Stopping application %s" % app_name)
    watch = "app___" + app_name
    monit_result = monit_interface.stop(watch)

    if not monit_result:
        logging.error("Unable to shut down monit interface for watch %s" % watch)
        return False

    return True
Пример #22
0
def stop_app(app_name):
  """ Stops all process instances of a Google App Engine application on this
      machine.

  Args:
    app_name: Name of application to stop
  Returns:
    True on success, False otherwise
  """
  if not misc.is_app_name_valid(app_name):
    logging.error("Unable to kill app process %s on because of " \
      "invalid name for application" % (app_name))
    return False

  logging.info("Stopping application %s" % app_name)
  watch = "app___" + app_name
  monit_result = monit_interface.stop(watch)

  if not monit_result:
    logging.error("Unable to shut down monit interface for watch %s" % watch)
    return False

  return True
Пример #23
0
def start_app(config):
  """ Starts a Google App Engine application on this machine. It
      will start it up and then proceed to fetch the main page.

  Args:
    config: a dictionary that contains
       app_name: Name of the application to start
       app_port: Port to start on
       language: What language the app is written in
       load_balancer_ip: Public ip of load balancer
       xmpp_ip: IP of XMPP service
       dblocations: List of database locations
       env_vars: A dict of environment variables that should be passed to the
        app.
       max_memory: An int that names the maximum amount of memory that this
        App Engine app is allowed to consume before being restarted.
  Returns:
    PID of process on success, -1 otherwise
  """
  config = convert_config_from_json(config)
  if config == None:
    logging.error("Invalid configuration for application")
    return BAD_PID

  if not misc.is_app_name_valid(config['app_name']):
    logging.error("Invalid app name for application: " +\
                  config['app_name'])
    return BAD_PID
  logging.info("Starting %s application %s"%(config['language'],
                                             config['app_name']))

  start_cmd = ""
  stop_cmd = ""
  env_vars = config['env_vars']
  env_vars['GOPATH'] = '/root/appscale/AppServer/gopath/'
  env_vars['GOROOT'] = '/root/appscale/AppServer/goroot/'
  watch = "app___" + config['app_name']

  if config['language'] == constants.PYTHON27 or \
       config['language'] == constants.GO or \
       config['language'] == constants.PHP:
    start_cmd = create_python27_start_cmd(config['app_name'],
                            config['load_balancer_ip'],
                            config['app_port'],
                            config['load_balancer_ip'],
                            config['xmpp_ip'])
    logging.info(start_cmd)
    stop_cmd = create_python27_stop_cmd(config['app_port'])
    env_vars.update(create_python_app_env(config['load_balancer_ip'],
                            config['app_name']))
  elif config['language'] == constants.JAVA:
    remove_conflicting_jars(config['app_name'])
    copy_successful = copy_modified_jars(config['app_name'])
    if not copy_successful:
      return BAD_PID
    start_cmd = create_java_start_cmd(config['app_name'],
                            config['app_port'],
                            config['load_balancer_ip'])
    stop_cmd = create_java_stop_cmd(config['app_port'])
    env_vars.update(create_java_app_env())
  else:
    logging.error("Unknown application language %s for appname %s"\
                  %(config['language'], config['app_name']))
    return BAD_PID

  logging.info("Start command: " + str(start_cmd))
  logging.info("Stop command: " + str(stop_cmd))
  logging.info("Environment variables: " +str(env_vars))

  monit_app_configuration.create_config_file(str(watch),
                                             str(start_cmd),
                                             str(stop_cmd),
                                             [config['app_port']],
                                             env_vars,
                                             config['max_memory'])

  if not monit_interface.start(watch):
    logging.error("Unable to start application server with monit")
    return BAD_PID

  if not wait_on_app(int(config['app_port'])):
    logging.error("Application server did not come up in time, " + \
                   "removing monit watch")
    monit_interface.stop(watch)
    return BAD_PID

  return 0
Пример #24
0
def start_app(config):
    """ Starts a Google App Engine application on this machine. It
      will start it up and then proceed to fetch the main page.

  Args:
    config: a dictionary that contains
       app_name: Name of the application to start
       app_port: Port to start on
       language: What language the app is written in
       load_balancer_ip: Public ip of load balancer
       xmpp_ip: IP of XMPP service
       dblocations: List of database locations
       env_vars: A dict of environment variables that should be passed to the
        app.
       max_memory: An int that names the maximum amount of memory that this
        App Engine app is allowed to consume before being restarted.
  Returns:
    PID of process on success, -1 otherwise
  """
    config = convert_config_from_json(config)
    if config == None:
        logging.error("Invalid configuration for application")
        return BAD_PID

    if not misc.is_app_name_valid(config['app_name']):
        logging.error("Invalid app name for application: " +\
                      config['app_name'])
        return BAD_PID
    logging.info("Starting %s application %s" %
                 (config['language'], config['app_name']))

    start_cmd = ""
    stop_cmd = ""
    env_vars = config['env_vars']
    env_vars['GOPATH'] = '/root/appscale/AppServer/gopath/'
    env_vars['GOROOT'] = '/root/appscale/AppServer/goroot/'
    watch = "app___" + config['app_name']

    if config['language'] == constants.PYTHON27 or \
         config['language'] == constants.GO or \
         config['language'] == constants.PHP:
        start_cmd = create_python27_start_cmd(config['app_name'],
                                              config['load_balancer_ip'],
                                              config['app_port'],
                                              config['load_balancer_ip'],
                                              config['xmpp_ip'])
        logging.info(start_cmd)
        stop_cmd = create_python27_stop_cmd(config['app_port'])
        env_vars.update(
            create_python_app_env(config['load_balancer_ip'],
                                  config['app_name']))
    elif config['language'] == constants.JAVA:
        remove_conflicting_jars(config['app_name'])
        copy_successful = copy_modified_jars(config['app_name'])
        if not copy_successful:
            return BAD_PID
        start_cmd = create_java_start_cmd(config['app_name'],
                                          config['app_port'],
                                          config['load_balancer_ip'])
        stop_cmd = create_java_stop_cmd(config['app_port'])
        env_vars.update(create_java_app_env())
    else:
        logging.error("Unknown application language %s for appname %s"\
                      %(config['language'], config['app_name']))
        return BAD_PID

    logging.info("Start command: " + str(start_cmd))
    logging.info("Stop command: " + str(stop_cmd))
    logging.info("Environment variables: " + str(env_vars))

    monit_app_configuration.create_config_file(str(watch), str(start_cmd),
                                               str(stop_cmd),
                                               [config['app_port']], env_vars,
                                               config['max_memory'])

    if not monit_interface.start(watch):
        logging.error("Unable to start application server with monit")
        return BAD_PID

    if not wait_on_app(int(config['app_port'])):
        logging.error("Application server did not come up in time, " + \
                       "removing monit watch")
        monit_interface.stop(watch)
        return BAD_PID

    return 0
Пример #25
0
def start_app(config):
    """ Starts a Google App Engine application on this machine. It
      will start it up and then proceed to fetch the main page.

  Args:
    config: a dictionary that contains
       app_name: Name of the application to start
       app_port: Port to start on
       language: What language the app is written in
       load_balancer_ip: Public ip of load balancer
       xmpp_ip: IP of XMPP service
       env_vars: A dict of environment variables that should be passed to the
        app.
       max_memory: An int that names the maximum amount of memory that this
        App Engine app is allowed to consume before being restarted.
       syslog_server: The IP of the syslog server to send the application
         logs to. Usually it's the login private IP.
  Returns:
    PID of process on success, -1 otherwise
  """
    config = convert_config_from_json(config)
    if config is None:
        logging.error("Invalid configuration for application")
        return BAD_PID

    if not misc.is_app_name_valid(config['app_name']):
        logging.error("Invalid app name for application: " +
                      config['app_name'])
        return BAD_PID
    logging.info("Starting %s application %s" %
                 (config['language'], config['app_name']))

    env_vars = config['env_vars']
    env_vars['GOPATH'] = '/root/appscale/AppServer/gopath/'
    env_vars['GOROOT'] = '/root/appscale/AppServer/goroot/'
    watch = "app___" + config['app_name']

    if config['language'] == constants.PYTHON27 or \
        config['language'] == constants.GO or \
        config['language'] == constants.PHP:
        start_cmd = create_python27_start_cmd(config['app_name'],
                                              config['load_balancer_ip'],
                                              config['app_port'],
                                              config['load_balancer_ip'],
                                              config['xmpp_ip'])
        stop_cmd = create_python27_stop_cmd(config['app_port'])
        env_vars.update(
            create_python_app_env(config['load_balancer_ip'],
                                  config['app_name']))
    elif config['language'] == constants.JAVA:
        remove_conflicting_jars(config['app_name'])
        copy_successful = copy_modified_jars(config['app_name'])
        if not copy_successful:
            return BAD_PID
        start_cmd = create_java_start_cmd(config['app_name'],
                                          config['app_port'],
                                          config['load_balancer_ip'])
        stop_cmd = create_java_stop_cmd(config['app_port'])
        env_vars.update(create_java_app_env(config['app_name']))
    else:
        logging.error("Unknown application language %s for appname %s" \
          % (config['language'], config['app_name']))
        return BAD_PID

    logging.info("Start command: " + str(start_cmd))
    logging.info("Stop command: " + str(stop_cmd))
    logging.info("Environment variables: " + str(env_vars))

    # Set the syslog_server is specified.
    syslog_server = ""
    if 'syslog_server' in config:
        syslog_server = config['syslog_server']
    monit_app_configuration.create_config_file(str(watch), str(start_cmd),
                                               str(stop_cmd),
                                               [config['app_port']], env_vars,
                                               config['max_memory'],
                                               syslog_server,
                                               appscale_info.get_private_ip())

    if not monit_interface.start(watch):
        logging.error("Unable to start application server with monit")
        return BAD_PID

    if not wait_on_app(int(config['app_port'])):
        logging.error("Application server did not come up in time, "
                      "removing monit watch")
        monit_interface.stop(watch)
        return BAD_PID

    threading.Thread(target=add_routing,
                     args=(config['app_name'], config['app_port'])).start()

    if 'log_size' in config.keys():
        log_size = config['log_size']
    else:
        if config['app_name'] == APPSCALE_DASHBOARD_ID:
            log_size = DASHBOARD_LOG_SIZE
        else:
            log_size = APP_LOG_SIZE

    if not setup_logrotate(config['app_name'], watch, log_size):
        logging.error(
            "Error while setting up log rotation for application: {}".format(
                config['app_name']))

    return 0
Пример #26
0
def start_app(config):
  """ Starts a Google App Engine application on this machine. It
      will start it up and then proceed to fetch the main page.

  Args:
    config: a dictionary that contains
       app_name: Name of the application to start
       app_port: Port to start on
       language: What language the app is written in
       load_balancer_ip: Public ip of load balancer
       xmpp_ip: IP of XMPP service
       env_vars: A dict of environment variables that should be passed to the
        app.
       max_memory: An int that names the maximum amount of memory that this
        App Engine app is allowed to consume before being restarted.
       syslog_server: The IP of the syslog server to send the application
         logs to. Usually it's the login private IP.
  Returns:
    PID of process on success, -1 otherwise
  """
  config = convert_config_from_json(config)
  if config == None:
    logging.error("Invalid configuration for application")
    return BAD_PID

  if not misc.is_app_name_valid(config['app_name']):
    logging.error("Invalid app name for application: " + config['app_name'])
    return BAD_PID
  logging.info("Starting %s application %s" % (
    config['language'], config['app_name']))

  env_vars = config['env_vars']
  env_vars['GOPATH'] = '/var/lib/appscale/AppServer/gopath/'
  env_vars['GOROOT'] = '/var/lib/appscale/AppServer/goroot/'
  watch = "app___" + config['app_name']

  if config['language'] == constants.PYTHON27 or \
      config['language'] == constants.GO or \
      config['language'] == constants.PHP:
    start_cmd = create_python27_start_cmd(
      config['app_name'],
      config['load_balancer_ip'],
      config['app_port'],
      config['load_balancer_ip'],
      config['xmpp_ip'])
    stop_cmd = create_python27_stop_cmd(config['app_port'])
    env_vars.update(create_python_app_env(
      config['load_balancer_ip'],
      config['app_name']))
  elif config['language'] == constants.JAVA:
    remove_conflicting_jars(config['app_name'])
    copy_successful = copy_modified_jars(config['app_name'])
    if not copy_successful:
      return BAD_PID
    start_cmd = create_java_start_cmd(
      config['app_name'],
      config['app_port'],
      config['load_balancer_ip'])
    stop_cmd = create_java_stop_cmd(config['app_port'])
    env_vars.update(create_java_app_env(config['app_name']))
  else:
    logging.error("Unknown application language %s for appname %s" \
      % (config['language'], config['app_name']))
    return BAD_PID

  logging.info("Start command: " + str(start_cmd))
  logging.info("Stop command: " + str(stop_cmd))
  logging.info("Environment variables: " + str(env_vars))

  # Set the syslog_server is specified.
  syslog_server = ""
  if 'syslog_server' in config:
    syslog_server = config['syslog_server']
  monit_app_configuration.create_config_file(
    str(watch),
    str(start_cmd),
    str(stop_cmd),
    [config['app_port']],
    env_vars,
    config['max_memory'],
    syslog_server,
    appscale_info.get_private_ip())

  if not monit_interface.start(watch):
    logging.error("Unable to start application server with monit")
    return BAD_PID

  if not wait_on_app(int(config['app_port'])):
    logging.error("Application server did not come up in time, "
      "removing monit watch")
    monit_interface.stop(watch)
    return BAD_PID

  threading.Thread(target=add_routing,
    args=(config['app_name'], config['app_port'])).start()

  if 'log_size' in config.keys():
    log_size = config['log_size']
  else:
    if config['app_name'] == APPSCALE_DASHBOARD_ID:
      log_size = DASHBOARD_LOG_SIZE
    else:
      log_size = APP_LOG_SIZE

  if not setup_logrotate(config['app_name'], watch, log_size):
    logging.error("Error while setting up log rotation for application: {}".
      format(config['app_name']))


  return 0