| #!/usr/bin/python |
| # coding: utf-8 |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| import subprocess, time, sys |
| import json |
| import datetime |
| from optparse import OptionParser |
| |
| SKIP_TEST="-DskipTests" |
| AMBARI_AUTH_HEADERS = "--header 'Authorization:Basic YWRtaW46YWRtaW4=' --header 'X-Requested-By: PIVOTAL'" |
| AMBARI_BUILD_DOCKER_ROOT = "/tmp/ambari-build-docker" |
| NO_EXIT_SLEEP_TIME=60 |
| RETRY_MAX=20 |
| |
| def git_deep_cleaning(): |
| proc = subprocess.Popen("git clean -xdf", |
| shell=True, |
| cwd="/tmp/ambari") |
| return proc.wait() |
| |
| def ambariUnitTest(): |
| proc = subprocess.Popen("mvn -fae clean install", |
| shell=True, |
| cwd="/tmp/ambari") |
| return proc.wait() |
| |
| def buildAmbari(stack_distribution): |
| stack_distribution_param = "" |
| if stack_distribution is not None: |
| stack_distribution_param = "-Dstack.distribution=" + stack_distribution |
| proc = subprocess.Popen("mvn -B clean install package rpm:rpm -Dmaven.clover.skip=true -Dfindbugs.skip=true " |
| + SKIP_TEST + " " |
| + stack_distribution_param + " -Dpython.ver=\"python >= 2.6\"", |
| shell=True, |
| cwd="/tmp/ambari") |
| return proc.wait() |
| |
| def install_ambari_server(): |
| proc = subprocess.Popen("sudo yum install -y ambari-server-*.x86_64.rpm", |
| shell=True, |
| cwd="/tmp/ambari/ambari-server/target/rpm/ambari-server/RPMS/x86_64") |
| return proc.wait() |
| |
| def install_ambari_agent(): |
| proc = subprocess.Popen("sudo yum install -y ambari-agent-*.x86_64.rpm", |
| shell=True, |
| cwd="/tmp/ambari/ambari-agent/target/rpm/ambari-agent/RPMS/x86_64") |
| return proc.wait() |
| |
| def setup_ambari_server(): |
| proc = subprocess.Popen("echo -e '\n\n\n\n' | sudo ambari-server setup", |
| shell=True) |
| return proc.wait() |
| |
| def start_ambari_server(debug=False): |
| proc = subprocess.Popen("sudo ambari-server start" + (" --debug" if debug else ""), |
| shell=True) |
| return proc.wait() |
| |
| def start_dependant_services(): |
| retcode = 0 |
| proc = subprocess.Popen("sudo service sshd start", shell=True) |
| retcode += proc.wait() |
| proc = subprocess.Popen("sudo service ntpd start", shell=True) |
| retcode += proc.wait() |
| return retcode |
| |
| def configure_ambari_agent(): |
| proc = subprocess.Popen("hostname -f", stdout=subprocess.PIPE, shell=True) |
| hostname = proc.stdout.read().rstrip() |
| proc = subprocess.Popen("sudo sed -i 's/hostname=localhost/hostname=" + hostname + "/g' /etc/ambari-agent/conf/ambari-agent.ini", |
| shell=True) |
| return proc.wait() |
| |
| def start_ambari_agent(wait_until_registered = True): |
| retcode = 0 |
| proc = subprocess.Popen("service ambari-agent start", |
| shell=True) |
| retcode += proc.wait() |
| if wait_until_registered: |
| if not wait_until_ambari_agent_registered(): |
| print "ERROR: ambari-agent was not registered." |
| sys.exit(1) |
| |
| return retcode |
| |
| def wait_until_ambari_agent_registered(): |
| ''' |
| return True if ambari agent is found registered. |
| return False if timeout |
| ''' |
| count = 0 |
| while count < RETRY_MAX: |
| count += 1 |
| proc = subprocess.Popen("curl " + |
| "http://localhost:8080/api/v1/hosts " + |
| AMBARI_AUTH_HEADERS, |
| stdout=subprocess.PIPE, |
| shell=True) |
| hosts_result_string = proc.stdout.read() |
| hosts_result_json = json.loads(hosts_result_string) |
| if len(hosts_result_json["items"]) != 0: |
| return True |
| time.sleep(5) |
| return False |
| |
| def post_blueprint(): |
| proc = subprocess.Popen("curl -X POST -D - " + |
| "-d @single-node-HDP-2.1-blueprint1.json http://localhost:8080/api/v1/blueprints/myblueprint1 " + |
| AMBARI_AUTH_HEADERS , |
| cwd=AMBARI_BUILD_DOCKER_ROOT + "/blueprints", |
| shell=True) |
| return proc.wait() |
| |
| def create_cluster(): |
| proc = subprocess.Popen("curl -X POST -D - " + |
| "-d @single-node-hostmapping1.json http://localhost:8080/api/v1/clusters/mycluster1 " + |
| AMBARI_AUTH_HEADERS , |
| cwd=AMBARI_BUILD_DOCKER_ROOT + "/blueprints", |
| shell=True) |
| return proc.wait() |
| |
| # Loop to not to exit Docker container |
| def no_exit(): |
| print "" |
| print "loop to not to exit docker container..." |
| print "" |
| while True: |
| time.sleep(NO_EXIT_SLEEP_TIME) |
| |
| class ParseResult: |
| is_deep_clean = False |
| is_rebuild = False |
| stack_distribution = None |
| is_test = False |
| is_install_server = False |
| is_install_agent = False |
| is_deploy = False |
| is_server_debug = False |
| |
| def parse(argv): |
| result = ParseResult() |
| if len(argv) >=2: |
| parser = OptionParser() |
| parser.add_option("-c", "--clean", |
| dest="is_deep_clean", |
| action="store_true", |
| default=False, |
| help="if this option is set, git clean -xdf is executed for the ambari local git repo") |
| |
| parser.add_option("-b", "--rebuild", |
| dest="is_rebuild", |
| action="store_true", |
| default=False, |
| help="set this flag if you want to rebuild Ambari code") |
| |
| parser.add_option("-s", "--stack_distribution", |
| dest="stack_distribution", |
| help="set a stack distribution. [HDP|PHD|BIGTOP]. Make sure -b is also set when you set a stack distribution") |
| |
| parser.add_option("-d", "--server_debug", |
| dest="is_server_debug", |
| action="store_true", |
| default=False, |
| help="set a debug option for ambari-server") |
| |
| (options, args) = parser.parse_args(argv[1:]) |
| if options.is_deep_clean: |
| result.is_deep_clean = True |
| if options.is_rebuild: |
| result.is_rebuild = True |
| if options.stack_distribution: |
| result.stack_distribution = options.stack_distribution |
| if options.is_server_debug: |
| result.is_server_debug = True |
| |
| if argv[0] == "test": |
| result.is_test = True |
| |
| if argv[0] == "server": |
| result.is_install_server = True |
| |
| if argv[0] == "agent": |
| result.is_install_server = True |
| result.is_install_agent = True |
| |
| if argv[0] == "deploy": |
| result.is_install_server = True |
| result.is_install_agent = True |
| result.is_deploy = True |
| |
| return result |
| |
| if __name__ == "__main__": |
| |
| if len(sys.argv) == 1: |
| print "specify one of test, server, agent or deploy" |
| sys.exit(1) |
| |
| start = datetime.datetime.utcnow() |
| |
| # test: execute unit test |
| # server: install ambari-server |
| # with or without rebuild |
| # agent: install ambari-server and ambari-agent |
| # with or without rebuild |
| # deploy: install ambari-server, ambari-agent and deploy Hadoop |
| # with or without rebuild |
| |
| parsed_args = parse(sys.argv[1:]) |
| |
| if parsed_args.is_deep_clean: |
| retcode = git_deep_cleaning() |
| if retcode != 0: sys.exit(retcode) |
| |
| if parsed_args.is_test: |
| retcode = ambariUnitTest() |
| end = datetime.datetime.utcnow() |
| print "" |
| print "Duration: " + str((end-start).seconds) + " seconds" |
| sys.exit(retcode) |
| |
| if parsed_args.is_rebuild: |
| retcode = buildAmbari(parsed_args.stack_distribution) |
| if retcode != 0: sys.exit(retcode) |
| |
| if parsed_args.is_install_server: |
| retcode = install_ambari_server() |
| if retcode != 0: sys.exit(retcode) |
| retcode = setup_ambari_server() |
| if retcode != 0: sys.exit(retcode) |
| retcode = start_ambari_server(parsed_args.is_server_debug) |
| if retcode != 0: sys.exit(retcode) |
| retcode = start_dependant_services() |
| if retcode != 0: sys.exit(retcode) |
| |
| if parsed_args.is_install_agent: |
| retcode = install_ambari_agent() |
| if retcode != 0: sys.exit(retcode) |
| retcode = configure_ambari_agent() |
| if retcode != 0: sys.exit(retcode) |
| retcode = start_ambari_agent() |
| if retcode != 0: sys.exit(retcode) |
| |
| if parsed_args.is_deploy: |
| retcode = post_blueprint() |
| if retcode != 0: sys.exit(retcode) |
| retcode = create_cluster() |
| if retcode != 0: sys.exit(retcode) |
| |
| end = datetime.datetime.utcnow() |
| |
| print "" |
| print "Duration: " + str((end-start).seconds) + " seconds" |
| print "Parameters: " + str(sys.argv) |
| no_exit() |