-#!/usr/bin/ruby -d
+#!/usr/bin/ruby
=begin
ftpsvr_port = ftp_result[1]
ftpsvr_username = ftp_result[2]
ftpsvr_passwd = ftp_result[3]
- BuildServerController.create_server( option[:name], Utils::WORKING_DIR, option[:url], pkgsvr_addr, pkgsvr_port, option[:pid], ftpsvr_addr, ftpsvr_port, ftpsvr_username, ftpsvr_passwd )
+ BuildServerController.create_server( option[:name], Utils::WORKING_DIR, ftpsvr_addr, ftpsvr_port, ftpsvr_username, ftpsvr_passwd, option[:url], pkgsvr_addr, pkgsvr_port )
when "remove"
BuildServerController.remove_server( option[:name] )
when "start"
=end
require 'fileutils'
+require 'sqlite3'
$LOAD_PATH.unshift File.dirname(__FILE__)
require "CommonProject.rb"
require "RegisterPackageJob.rb"
attr_accessor :pkg_name
# initialize
- def initialize( name, pkg_name, server, os_list )
+ def initialize( name, server, os_list, pkg_name = nil )
super(name, "BINARY", server, os_list)
@pkg_name = pkg_name
end
return false
end
end
+
+
+ def save_db()
+ config_file = "#{@server.path}/projects/#{@name}/build"
+ File.open( config_file, "w" ) do |f|
+ f.puts "TYPE=BINARY"
+ f.puts "PACKAGE_NAME=#{@pkg_name}"
+ end
+ end
+
+
+ def load_db()
+ # git
+ config_file = "#{@server.path}/projects/#{@name}/build"
+ pkg_name=nil
+ File.open( config_file, "r" ) do |f|
+ f.each_line do |l|
+ idx = l.index("=") + 1
+ length = l.length - idx
+
+ if l.start_with?("PACKAGE_NAME=")
+ pkg_name = l[idx,length].strip
+ else
+ next
+ end
+ end
+ end
+
+ @pkg_name = pkg_name
+ end
end
=end
require 'fileutils'
+require 'sqlite3'
$LOAD_PATH.unshift File.dirname(__FILE__)
require "SocketJobRequestListener.rb"
require "RemoteBuildJob.rb"
require "ProjectManager.rb"
class BuildServer
- attr_accessor :id, :path, :pkgserver_url, :pkgserver_addr, :pkgserver_port, :pkgserver_id, :port, :status, :friend_servers, :host_os, :log
+ attr_accessor :id, :path, :pkgserver_url, :pkgserver_addr, :pkgserver_port, :port, :status, :friend_servers, :host_os, :log
attr_accessor :git_server_url, :git_bin_path
attr_accessor :job_log_url
attr_accessor :allowed_git_branch
HOST_OS = Utils::HOST_OS
# initialize
- def initialize (id, path, pkgsvr_url, pkgsvr_addr, pkgsvr_port, pkgsvr_id, ftpsvr_addr, ftpsvr_port, ftpsvr_username, ftpsvr_passwd)
+ def initialize (id, path, ftpsvr_addr, ftpsvr_port, ftpsvr_username, ftpsvr_passwd)
@id = id
@path = path
- @pkgserver_url = pkgsvr_url
- @pkgserver_addr = pkgsvr_addr
- @pkgserver_port = pkgsvr_port
- @pkgserver_id = pkgsvr_id
+ @pkgserver_url = nil
+ @pkgserver_addr = nil
+ @pkgserver_port = nil
@friend_servers = []
@remote_pkg_servers = []
@req_listener = []
# start server daemon
def start
- # start
- @log = Log.new( "#{BuildServer::CONFIG_ROOT}/#{@id}/log" )
-
# set build cache dir
@build_cache_dir="#{BuildServer::CONFIG_ROOT}/#{@id}/build_cache"
if not File.exist? @build_cache_dir then
return @jobmgr.has_waiting_jobs
end
+
+ def db_exist?
+ if File.exist? "#{BuildServer::CONFIG_ROOT}/#{@id}/server.db" then
+ return true
+ else
+ return false
+ end
+ end
+
+
+ def create_db()
+ # create DB
+ db_file = "#{BuildServer::CONFIG_ROOT}/#{@id}/server.db"
+ begin
+ db = SQLite3::Database.new db_file
+
+ # create table
+ db.execute "CREATE TABLE IF NOT EXISTS distributions(name VARCHAR(32) PRIMARY KEY, pkgsvr_url VARCHAR(256), pkgsvr_addr VARCHAR(64))"
+ db.execute "CREATE TABLE IF NOT EXISTS remote_build_servers(id INTEGER PRIMARY KEY, svr_addr VARCHAR(64))"
+ db.execute "CREATE TABLE IF NOT EXISTS sync_pkg_servers(id INTEGER PRIMARY KEY, pkgsvr_url VARCHAR(256), period INTEGER)"
+ db.execute "CREATE TABLE IF NOT EXISTS supported_os(name VARCHAR(32) PRIMARY KEY)"
+ db.execute "CREATE TABLE IF NOT EXISTS projects(id INTEGER PRIMARY KEY, name VARCHAR(32), type VARCHAR(32), password VARCHAR(32), dist_name VARCHAR(32))"
+ db.execute "CREATE TABLE IF NOT EXISTS project_os(prj_id INTEGER, os_name VARCHAR(32))"
+ rescue SQLite3::Exception => e
+ puts "DB Creation failed!"
+ puts e
+ ensure
+ db.close if db
+ end
+ end
+
+
+ # save
+ def save_db()
+ db_file = "#{BuildServer::CONFIG_ROOT}/#{@id}/server.db"
+ begin
+ # open DB
+ db = SQLite3::Database.open db_file
+
+ # distributions
+ url = @pkgserver_url
+ addr = @pkgserver_addr + ":" + @pkgserver_port.to_s
+ db.execute "DELETE FROM distributions"
+ db.execute "INSERT INTO distributions VALUES('BASE','#{url}','#{addr}')"
+
+ # remote_build_servers
+ db.execute "DELETE FROM remote_build_servers"
+ idx = 0
+ @friend_servers.each { |svr|
+ db.execute "INSERT INTO remote_build_servers VALUES('#{idx}','#{svr.ip}:#{svr.port}')"
+ idx += 1
+ }
+
+ # sync_pkg_servers
+ db.execute "DELETE FROM sync_pkg_servers"
+ idx = 0
+ @remote_pkg_servers.each { |svr|
+ db.execute "INSERT INTO sync_pkg_servers VALUES('#{idx}','#{svr[0]}','#{@pkg_sync_period}')"
+ idx += 1
+ }
+
+ # supported_os
+ db.execute "DELETE FROM supported_os"
+ @supported_os_list.each { |os|
+ db.execute "INSERT INTO supported_os VALUES('#{os}')"
+ }
+
+ rescue SQLite3::Exception => e
+ puts "DB update failed!"
+ puts e
+ ensure
+ db.close if db
+ end
+ end
+
+
+ # load
+ def load_db()
+ db_file = "#{BuildServer::CONFIG_ROOT}/#{@id}/server.db"
+ begin
+ # open DB
+ db = SQLite3::Database.open db_file
+ db.results_as_hash = true
+
+ # distributions
+ stm = db.prepare "SELECT * FROM distributions"
+ rs = stm.execute
+ rs.each { |row|
+ @pkgserver_url = row['pkgsvr_url']
+ @pkgserver_addr = row['pkgsvr_addr'].split(":")[0]
+ @pkgserver_port = row['pkgsvr_addr'].split(":")[1].to_i
+ }
+ stm.close if stm
+
+ # remote_build_servers
+ @friend_servers = []
+ stm = db.prepare "SELECT * FROM remote_build_servers"
+ rs = stm.execute
+ rs.each { |row|
+ add_remote_server(
+ row['svr_addr'].split(":")[0],
+ row['svr_addr'].split(":")[1].to_i)
+ }
+ stm.close if stm
+
+ # sync_package_servers
+ @remote_pkg_servers = []
+ stm = db.prepare "SELECT * FROM sync_pkg_servers"
+ rs = stm.execute
+ rs.each { |row|
+ add_remote_package_server( row['pkgsvr_url'], nil )
+ @pkg_sync_period = row['period'].to_i
+ }
+ stm.close if stm
+
+ # supported_os
+ @supported_os_list = []
+ stm = db.prepare "SELECT * FROM supported_os"
+ rs = stm.execute
+ rs.each { |row|
+ add_target_os( row['name'] )
+ }
+ rescue SQLite3::Exception => e
+ puts "DB loading failed!"
+ puts e
+ ensure
+ stm.close if stm
+ db.close if db
+ end
+ end
+
end
@@instance_map = {}
# create
- def self.create_server (id, path, pkgsvr_url, pkgsvr_addr, pkgsvr_port, pkgsvr_id, ftpsvr_addr, ftpsvr_port, ftpsvr_username, ftpsvr_passwd)
+ def self.create_server (id, path, ftpsvr_addr, ftpsvr_port, ftpsvr_username, ftpsvr_passwd, pkgsvr_url=nil, pkgsvr_addr=nil, pkgsvr_port=3333 )
# check server config root
check_build_server_root
end
# create new instance and return it
- @@instance_map[id] = BuildServer.new( id, path, pkgsvr_url, pkgsvr_addr, pkgsvr_port, pkgsvr_id, ftpsvr_addr, ftpsvr_port, ftpsvr_username, ftpsvr_passwd)
+ @@instance_map[id] = BuildServer.new( id, path, ftpsvr_addr, ftpsvr_port, ftpsvr_username, ftpsvr_passwd)
# set default
- @@instance_map[id].git_server_url="gerrithost:"
if Utils.is_windows_like_os(Utils::HOST_OS) then
@@instance_map[id].git_bin_path="/c/Program\\ Files/Git/bin/git.exe"
else
@@instance_map[id].git_bin_path="/usr/bin/git"
end
- @@instance_map[id].allowed_git_branch=nil
@@instance_map[id].jobmgr.max_working_jobs= 2
@@instance_map[id].job_log_url=""
@@instance_map[id].send_mail="NO"
+ @@instance_map[id].pkgserver_url=pkgsvr_url
+ @@instance_map[id].pkgserver_addr=pkgsvr_addr
+ @@instance_map[id].pkgserver_port=pkgsvr_port
-
# write config
write_server_config( @@instance_map[id] )
# get server config and return its object
@@instance_map[id] = read_server_config(id)
+ # set logger first
+ @@instance_map[id].log = Log.new( "#{BuildServer::CONFIG_ROOT}/#{id}/log" )
+
return @@instance_map[id]
end
# add
if server.add_remote_server( ip, port ) then
-
- # write config
- server_dir = "#{BuildServer::CONFIG_ROOT}/#{server.id}"
- f = File.open( "#{server_dir}/friends", "a" )
- f.puts "#{ip},#{port}"
- f.close
-
+ server.save_db()
puts "Friend server is added successfully!"
return true
# add
if server.add_remote_package_server( url, proxy ) then
-
- # write config
- server_dir = "#{BuildServer::CONFIG_ROOT}/#{server.id}"
- f = File.open( "#{server_dir}/remote_pkg_servers", "a" )
- if not proxy.nil? then
- f.puts "#{url}|#{proxy}"
- else
- f.puts "#{url}|"
- end
- f.close
-
+ server.save_db()
puts "Remote package server is added!"
-
return true
else
puts "The server already exists in list!"
-
return false
end
end
# add
if server.add_target_os( os_name ) then
-
- # write config
- server_dir = "#{BuildServer::CONFIG_ROOT}/#{server.id}"
- f = File.open( "#{server_dir}/supported_os_list", "a" )
- f.puts "#{os_name}"
- f.close
-
+ server.save_db()
puts "Target OS is added successfully!"
-
return true
else
puts "Target OS already exists in list!"
File.open( "#{server_dir}/server.cfg", "w" ) do |f|
f.puts "ID=#{server.id}"
f.puts "PATH=#{server.path}"
- f.puts "PSERVER_URL=#{server.pkgserver_url}"
- f.puts "PSERVER_ADDR=#{server.pkgserver_addr}"
- f.puts "PSERVER_PORT=#{server.pkgserver_port}"
- f.puts "PSERVER_ID=#{server.pkgserver_id}"
- f.puts "GIT_SERVER_URL=#{server.git_server_url}"
f.puts "GIT_BIN_PATH=#{server.git_bin_path}"
- f.puts "ALLOWED_GIT_BRANCH=#{server.allowed_git_branch}"
f.puts "MAX_WORKING_JOBS=#{server.jobmgr.max_working_jobs}"
f.puts "JOB_LOG_URL=#{server.job_log_url}"
f.puts "SEND_MAIL=#{server.send_mail}"
f.puts "FTP_PORT=#{server.ftp_port}"
f.puts "FTP_USERNAME=#{server.ftp_username}"
f.puts "FTP_PASSWD=#{server.ftp_passwd}"
- f.puts "PKG_SYNC_PERIOD=#{server.pkg_sync_period}"
end
+
+ # save to server.db
+ if not server.db_exist? then
+ server.create_db()
+ end
+ server.save_db()
end
# read server configuration
def self.read_server_config( id )
path=""
- pkgsvr_url=""
- pkgsvr_addr=""
- pkgsvr_port="3333"
- pkgsvr_id=""
- git_server_url="gerrithost:"
git_bin_path="/usr/bin/git"
- allowed_git_branch=""
max_working_jobs= 2
job_log_url=""
send_mail="NO"
ftp_port="21"
ftp_username=""
ftp_passwd=""
- pkg_sync_period=600
# read configuration
server_dir = "#{BuildServer::CONFIG_ROOT}/#{id}"
if l.start_with?("PATH=")
path = l[idx,length].strip
- elsif l.start_with?("PSERVER_URL=")
- pkgsvr_url = l[idx,length].strip
- elsif l.start_with?("PSERVER_ADDR=")
- pkgsvr_addr = l[idx,length].strip
- elsif l.start_with?("PSERVER_PORT=")
- pkgsvr_port = l[idx,length].strip
- elsif l.start_with?("PSERVER_ID=")
- pkgsvr_id = l[idx,length].strip
- elsif l.start_with?("GIT_SERVER_URL=")
- git_server_url = l[idx,length].strip
elsif l.start_with?("GIT_BIN_PATH=")
git_bin_path = l[idx,length].strip
- elsif l.start_with?("ALLOWED_GIT_BRANCH=")
- allowed_git_branch = l[idx,length].strip
elsif l.start_with?("MAX_WORKING_JOBS=")
max_working_jobs = l[idx,length].strip.to_i
elsif l.start_with?("JOB_LOG_URL=")
ftp_username = l[idx,length].strip
elsif l.start_with?("FTP_PASSWD=")
ftp_passwd = l[idx,length].strip
- elsif l.start_with?("PKG_SYNC_PERIOD=")
- pkg_sync_period = l[idx,length].strip.to_i
else
next
end
end
# create server object
- obj = BuildServer.new( id, path, pkgsvr_url, pkgsvr_addr, pkgsvr_port, pkgsvr_id, ftp_addr, ftp_port, ftp_username, ftp_passwd )
+ obj = BuildServer.new( id, path, ftp_addr, ftp_port, ftp_username, ftp_passwd )
# check running port
if File.exist? "#{server_dir}/run" then
f.close
end
- # check friend server
- if File.exist? "#{server_dir}/friends" then
- File.open( "#{server_dir}/friends", "r" ) do |f|
- f.each_line do |l|
- if l.split(",").count < 2 then next end
- ip = l.split(",")[0].strip
- port = l.split(",")[1].strip
- obj.add_remote_server( ip, port.to_i )
- end
- end
- end
-
- # check remote package server
- if File.exist? "#{server_dir}/remote_pkg_servers" then
- File.open( "#{server_dir}/remote_pkg_servers", "r" ) do |f|
- f.each_line do |l|
- if l.split("|").count < 2 then next end
- url = l.split("|")[0].strip
- proxy = l.split("|")[1].strip
- obj.add_remote_package_server( url, proxy )
- end
- end
- end
-
- # check supported os
- if File.exist? "#{server_dir}/supported_os_list" then
- File.open( "#{server_dir}/supported_os_list", "r" ) do |f|
- f.each_line do |l|
- os_name = l.strip
- obj.add_target_os( os_name )
- end
- end
- end
-
- # set git server url
- obj.git_server_url = git_server_url
-
# set git binary path
obj.git_bin_path = git_bin_path
# set send mail
obj.send_mail = send_mail
- # set allowed git branch name
- obj.allowed_git_branch = allowed_git_branch
-
# set test time
obj.test_time = test_time
obj.ftp_username = ftp_username
obj.ftp_passwd = ftp_passwd
- # pkg synchronization
- obj.pkg_sync_period = pkg_sync_period
+ # load from DB
+ obj.load_db()
# save config
write_server_config( obj )
# initialize
def initialize( name, type, server, os_list )
+ @project_id = -1
@name = name
@type = type
@passwd = ""
end
return nil
end
+
+
+ def set_project_id(id)
+ @project_id = id
+ end
+
+
+ def get_project_id()
+ return @project_id
+ end
end
=end
require 'fileutils'
+require 'sqlite3'
$LOAD_PATH.unshift File.dirname(__FILE__)
require "CommonProject.rb"
require "GitBuildJob.rb"
attr_accessor :repository, :branch
# initialize
- def initialize( name, repos, branch, server, os_list )
+ def initialize( name, server, os_list, repos = nil, branch = nil )
super(name, "GIT", server, os_list)
@repository = repos
@branch = branch
return false
end
+ def save_db()
+ config_file = "#{@server.path}/projects/#{@name}/build"
+ File.open( config_file, "w" ) do |f|
+ f.puts "TYPE=GIT"
+ f.puts "GIT_REPOSITORY=#{@repository}"
+ f.puts "GIT_BRANCH=#{@branch}"
+ end
+ end
+
+
+ def load_db()
+ # git
+ config_file = "#{@server.path}/projects/#{@name}/build"
+ repos="none"
+ branch="master"
+ File.open( config_file, "r" ) do |f|
+ f.each_line do |l|
+ idx = l.index("=") + 1
+ length = l.length - idx
+
+ if l.start_with?("GIT_REPOSITORY=")
+ repos = l[idx,length].strip
+ elsif l.start_with?("GIT_BRANCH=")
+ branch = l[idx,length].strip
+ else
+ next
+ end
+ end
+ end
+ @repository = repos
+ @branch = branch
+
+ # read source info
+ sources_file = "#{@server.path}/projects/#{@name}/sources"
+ if File.exist? sources_file then
+ File.open(sources_file, "r") do |f|
+ f.each_line do |l|
+ version = l.split(",")[0].strip
+ info = l.split(",")[1].strip
+
+ add_source_info( version, info )
+ end
+ end
+ end
+
+ # read pkginfo
+ pkginfo_dir = "#{@server.path}/projects/#{@name}/pkginfos"
+ if not File.exist? pkginfo_dir then FileUtils.mkdir_p pkginfo_dir end
+ Dir.new(pkginfo_dir).entries.each do |file|
+ if file.eql? "." or file.eql? ".." then next end
+
+ vlen = file.length - ".manifest".length
+ version = file[0,vlen]
+ add_package_info( version, "#{pkginfo_dir}/#{file}" )
+ end
+ end
end
=end
require 'fileutils'
+require 'sqlite3'
$LOAD_PATH.unshift File.dirname(__FILE__)
require "GitBuildProject.rb"
require "BinaryUploadProject.rb"
FileUtils.mkdir_p @project_root
end
- # scan all projects
- Dir.new(@project_root).entries.each do |name|
- # skip . or ..
- if name.eql? "." or name.eql? ".." then next end
-
- # create project
- @server.log.info "Loading project : #{name}"
- prj = load_project( name )
- if not prj.nil? then
- @projects.push prj
- end
- end
-
+ # load_data base
+ load_db()
end
def add_git_project(name , repos, branch, passwd, os_list)
+ load_db()
+
prj = get_project( name)
if not prj.nil? then return false end
- new_prj = GitBuildProject.new(name, repos, branch, @server, os_list)
+ new_prj = GitBuildProject.new(name, @server, os_list, repos, branch)
if not passwd.nil? and not passwd.empty? then
new_prj.passwd = passwd
end
+ new_prj.repository = repos
+ new_prj.branch = branch
@projects.push new_prj
# check project directory
end
# write configuration
- write_configuration(name, repos, branch, passwd, os_list)
+ save_db()
return true
end
def add_binary_project(name, pkg_name, passwd, os_list)
+ load_db()
+
prj = get_project( name)
if not prj.nil? then return false end
- new_prj = BinaryUploadProject.new(name, pkg_name, @server, os_list)
+ new_prj = BinaryUploadProject.new(name, @server, os_list, pkg_name)
if not passwd.nil? and not passwd.empty? then
new_prj.passwd = passwd
end
+ new_prj.pkg_name = pkg_name
@projects.push new_prj
# check project directory
FileUtils.mkdir_p "#{@project_root}/#{name}"
end
- # write configuration
- write_configuration_for_binary_project(name, pkg_name, passwd, os_list)
+ save_db()
return true
end
return get_project(name)
end
+
+ # save
+ def save_db()
+ # generate project id if not exist?
+ last_id = -1
+ @projects.each { |prj|
+ if prj.get_project_id() > last_id then last_id = prj.get_project_id() end
+ }
+ new_id = last_id + 1
+ @projects.each { |prj|
+ if prj.get_project_id() == -1 then
+ prj.set_project_id(new_id)
+ new_id += 1
+ end
+ }
+
+ db_file = "#{BuildServer::CONFIG_ROOT}/#{@server.id}/server.db"
+ begin
+ # open DB
+ db = SQLite3::Database.open db_file
+ db.results_as_hash = true
+
+ # delete all rows
+ db.execute "DELETE FROM projects"
+ db.execute "DELETE FROM project_os"
+
+ # insert project info
+ @projects.each { |prj|
+ prj_id = prj.get_project_id()
+ # COMMON
+ db.execute "INSERT INTO projects VALUES(#{prj_id}, '#{prj.name}', '#{prj.type}', '#{prj.passwd}', 'BASE')"
+
+ # OS
+ prj.os_list.each { |os|
+ db.execute "INSERT INTO project_os VALUES('#{prj_id}','#{os}')"
+ }
+
+ prj.save_db()
+ }
+ rescue SQLite3::Exception => e
+ puts "DB update failed!"
+ puts e
+ ensure
+ db.close if db
+ end
+ end
+
+
+ # load
+ def load_db()
+ @project = []
+
+ db_file = "#{BuildServer::CONFIG_ROOT}/#{@server.id}/server.db"
+ begin
+ # open DB
+ db = SQLite3::Database.open db_file
+ db.results_as_hash = true
+
+ # distributions
+ stm = db.prepare "SELECT * FROM projects"
+ rs = stm.execute
+ stm2 = nil
+ rs.each { |row|
+ prj_id = row['id']
+ prj_name = row['name']
+ prj_type = row['type']
+ prj_passwd = row['password']
+ prj_dist = row['dist_name']
+
+ @server.log.info "Loading project : #{prj_name}"
+ # os
+ prj_os_list = []
+ stm2 = db.prepare "SELECT os_name FROM project_os WHERE prj_id = #{prj_id}"
+ rs2 = stm2.execute
+ rs2.each { |row2|
+ prj_os_list.push row2[0]
+ }
+ stm2.close if stm2
+ stm2 = nil
+
+ if prj_type == "GIT" then
+ new_project = GitBuildProject.new(prj_name, @server, prj_os_list)
+ else
+ new_project = BinaryUploadProject.new(prj_name, @server, prj_os_list)
+ end
+ new_project.set_project_id(prj_id)
+
+ if not prj_passwd.empty? then
+ new_project.passwd = prj_passwd
+ end
+
+ new_project.load_db()
+
+ @projects.push new_project
+ }
+ rescue SQLite3::Exception => e
+ puts "DB loading failed!"
+ puts e
+ ensure
+ stm.close if stm
+ stm2.close if stm2
+ db.close if db
+ end
+ end
+
protected
# load and create project
# write back & create project
if type == "GIT" then
write_configuration(name, repos, branch, passwd, os_list)
- new_project = GitBuildProject.new(name, repos, branch, @server, os_list)
+ new_project = GitBuildProject.new(name, @server, os_list, repos, branch)
# read source info
sources_file = "#{@project_root}/#{name}/sources"
elsif type == "BINARY" then
write_configuration_for_binary_project(name, pkg_name, passwd, os_list)
- new_project = BinaryUploadProject.new(name, pkg_name, @server, os_list)
+ new_project = BinaryUploadProject.new(name, @server, os_list, pkg_name)
end
end
end
-
end
../build-svr add-prj -n testserver3 -N teste -P bin
../build-svr add-prj -n testserver3 -N testa1 -g `pwd`/git01/a1 -b master
../pkg-svr register -n pkgsvr01 -d unstable -P bin/bin_0.0.0_ubuntu-32.zip
-../build-svr start -n testserver3 -p 2223
+../build-svr start -n testserver3 -p 2223 --CHILD
projects / sdk / tools / sdk-build.git / commitdiff