Merge pull request apache#7 from mesosphere/add-token

Add token

Author: ssk2

README.md

@@ -32,7 +32,12 @@ When run with the `uninstall` command, it will:
     git clone https://github.com/mesosphere/cd-demo.git
     ```
 2. [Set up the DCOS CLI](https://docs.mesosphere.com/administration/introcli/cli/) locally.
-3. Ensure you have a DCOS cluster available. 1 node will work but more than 1 node is preferable to demonstrate build parallelism.
+3. Ensure you have a DCOS cluster available. 1 node will work but more than 1 node is preferable to demonstrate build parallelism. If you already had the CLI installed, make sure you set the new cluster URL and authenticate against it:
+
+    ```
+    dcos config set core.dcos_url http://my.dcos.cluster/
+    dcos auth login
+    ```
 
 ### Running Demo
 
@@ -41,7 +46,7 @@ When run with the `uninstall` command, it will:
     ```
     bin/demo.py install --branch=my-demo-branch --password=mypass123 http://my.dcos.cluster/
     ```
-    NOTE: Dependeing on your environment you may need to prepend the above command with `python` Also you must use the          domain name for your cluster; the IP address will fail.
+    NOTE: Depending on your environment you may need to prepend the above command with `python` Also you must use the domain name for your cluster; the IP address will fail.
     
 2. The script will install Jenkins and pause. Check that the Jenkins UI is running before hitting enter to proceed.
 3. The script will now use the Jenkins HTTP API to install jobs, necessary credentials and a view. It will automatically trigger the initial build before pausing.

bin/demo.py

@@ -32,21 +32,46 @@
 pass or fail. The duration of each job will be between 120 and 240 seconds.
 """
 
-from docopt import docopt
 import json
 import os
 import random
-import requests
 import shutil
-from subprocess import call
+from subprocess import call, CalledProcessError, check_output
+
+import requests
+from docopt import docopt
 
 def log(message):
     print "[demo] {}".format(message)
 
+def log_and_exit(message):
+    log(message)
+    exit(1)
+
+def get_auth_wrapper(token_arg):
+    def auth_wrapper(headers):
+        if token_arg is not None and len(token_arg.strip()) > 0:
+            headers['Authorization'] = "token={}".format(token_arg)
+        return headers
+    return auth_wrapper
+
+auth_func = get_auth_wrapper(None)
+
+def check_and_set_token(jenkins_url):
+    try:
+        global auth_func
+        command = "dcos config show core.dcos_acs_token"
+        token = check_output(command, shell=True).strip('\n')
+        auth_func = get_auth_wrapper(token)
+        r = requests.get(jenkins_url, headers=auth_func({}))
+        if r.status_code == 401:
+            log_and_exit("Not authenticated. Please run `dcos auth login` and try again.")
+    except CalledProcessError:
+        log_and_exit ("Not authenticated. Please run `dcos auth login` and try again.")
+
 def config_dcos_cli(dcos_url):
     if call (["dcos", "config", "set", "core.dcos_url", dcos_url],stdout=open(os.devnull, 'wb')) == 1:
-        log("Unable to configure DCOS CLI.")
-        exit(1)
+        log_and_exit ("Unable to configure DCOS CLI.")
 
 def make_temp_dir():
     remove_temp_dir()
@@ -66,13 +91,12 @@ def install(dcos_url, jenkins_name, jenkins_url):
     command = "dcos package install --yes --options=tmp/jenkins.json jenkins"
     print ("\n> " + command)
     if call (['dcos', 'package', 'install', '--yes', '--options=tmp/jenkins.json', 'jenkins']) != 0:
-        log ("Failed to install Jenkins")
-        exit(1)
+        log_and_exit ("Failed to install Jenkins.")
     print("\n[demo] Jenkins has been installed! Wait for it to come up before proceeding at: {}".format(jenkins_url))
     raw_input("[demo] Press [Enter] to continue, or ^C to cancel...")
 
 def verify(jenkins_url):
-    r = requests.get(jenkins_url)
+    r = requests.get(jenkins_url, headers=auth_func({}))
     if r.status_code != 200:
         log ("Couldn't find a Jenkins instance running at {}".format(jenkins_url))
         return False
@@ -82,53 +106,53 @@ def verify(jenkins_url):
 def create_credentials(jenkins_url, id, username, password):
     credential = { 'credentials' : { 'scope' : 'GLOBAL', 'id' : id, 'username' : username, 'password' : password, 'description' : id, '$class' : 'com.cloudbees.plugins.credentials.impl.UsernamePasswordCredentialsImpl'} }
     data = {'json' : json.dumps(credential) }
+    headers = auth_func({})
     post_url = "{}/credential-store/domain/_/createCredentials".format(jenkins_url)
-    r = requests.post(post_url, data=data)
+    r = requests.post(post_url, headers=headers, data=data)
 
 def create_job(jenkins_url, job_name, job_config):
     log ("Creating job")
-    headers = {'Content-Type' : 'application/xml' }
+    headers = auth_func({'Content-Type' : 'application/xml' })
     post_url = "{}/createItem?name={}".format(jenkins_url, job_name)
     r = requests.post(post_url, headers=headers, data=job_config)
     if r.status_code != 200:
-        log ("Failed to create job {} at {}".format(job_name, jenkins_url))
-        exit(1)
-    log ("Job {} created successfully".format(job_name))
+        log_and_exit ("Failed to create job {} at {}".format(job_name, jenkins_url))
+    log ("Job {} created successfully.".format(job_name))
 
 def create_view(jenkins_url, view_name, view_config):
     log ("Creating view")
-    headers = {'Content-Type' : 'text/xml' }
+    headers = auth_func({'Content-Type' : 'text/xml' })
     post_url = "{}/createView?name={}".format(jenkins_url, view_name)
     r = requests.post(post_url, headers=headers, data=view_config)
 
 def trigger_build(jenkins_url, job_name, parameter_string = None):
-    log ("Triggering build {}".format(job_name))
+    log ("Triggering build {}.".format(job_name))
     if parameter_string:
         post_url = "{}/job/{}/buildWithParameters?{}".format(jenkins_url, job_name, parameter_string)
     else:
         post_url = "{}/job/{}/build".format(jenkins_url, job_name)
-    r = requests.post(post_url)
+    r = requests.post(post_url, headers=auth_func({}))
 
 def delete_credentials(jenkins_url, credential_name):
-    log ("Deleting credentials {}".format(credential_name))
+    log ("Deleting credentials {}.".format(credential_name))
     post_url = "{}/credential-store/domain/_/credential/{}/doDelete".format(jenkins_url, credential_name)
-    r = requests.post(post_url)
+    r = requests.post(post_url, headers=auth_func({}))
 
 def delete_job(jenkins_url, job_name):
-    log ("Deleting job {}".format(job_name))
+    log ("Deleting job {}.".format(job_name))
     post_url = "{}/job/{}/doDelete".format(jenkins_url, job_name)
-    r = requests.post(post_url)
+    r = requests.post(post_url, headers=auth_func({}))
 
 def delete_view(jenkins_url, view_name):
-    log ("Deleting view {}".format(view_name))
+    log ("Deleting view {}.".format(view_name))
     post_url = "{}/view/{}/doDelete".format(jenkins_url, view_name)
-    r = requests.post(post_url)
+    r = requests.post(post_url, headers=auth_func({}))
 
 def remove_temp_dir():
     shutil.rmtree("tmp", ignore_errors=True)
 
 def demo_pipeline(jenkins_url, dcos_url, name, branch, org, username, password):
-    log ("Creating demo pipeline")
+    log ("Creating demo pipeline.")
     create_credentials(jenkins_url, 'docker-hub-credentials', username, password)
     with open("jobs/build-cd-demo/config.xml") as build_job:
         job_config = build_job.read().replace("GIT_BRANCH", branch)
@@ -146,11 +170,11 @@ def demo_pipeline(jenkins_url, dcos_url, name, branch, org, username, password):
         view_config = pipeline_view.read()
         create_view(jenkins_url, "cd-demo-pipeline", view_config)
     trigger_build(jenkins_url, "build-cd-demo")
-    log ("Created demo pipeline")
+    log ("Created demo pipeline.")
     raw_input("[demo] Press [Enter] to continue, or ^C to cancel...")
 
 def demo_dynamic_slaves(jenkins_url, builds):
-    log ("Creating {} freestyle Jenkins jobs".format(builds))
+    log ("Creating {} freestyle Jenkins jobs.".format(builds))
     random.seed()
     with open("jobs/demo-job/config.xml") as demo_job:
         job_config = demo_job.read()
@@ -162,36 +186,35 @@ def demo_dynamic_slaves(jenkins_url, builds):
             parameter_string = '?DURATION={}&RESULT={}'.format(duration, result)
             trigger_build(jenkins_url, job_name, parameter_string)
             log ("Job {} created successfully. Duration: {}. Result: {}. Triggering build.".format(job_name, duration, result))
-    log ("Created {} freestyle Jenkins jobs".format(builds))
+    log ("Created {} freestyle Jenkins jobs.".format(builds))
     raw_input("[demo] Press [Enter] to continue, or ^C to cancel...")
 
 def cleanup_pipeline_jobs (jenkins_url):
-    log ("Cleaning up demo pipeline")
+    log ("Cleaning up demo pipeline.")
     delete_credentials(jenkins_url, "docker-hub-credentials")
     delete_view(jenkins_url, "cd-demo-pipeline")
     delete_job(jenkins_url, "deploy-cd-demo")
     delete_job(jenkins_url, "test-cd-demo")
     delete_job(jenkins_url, "build-cd-demo")
 
 def cleanup_dynamic_slaves_jobs(jenkins_url, builds):
-    log ("Cleaning up {} builds".format(builds))
+    log ("Cleaning up {} builds.".format(builds))
     for i in range(1, builds):
         job_name = "demo-job-{0:02d}".format(i)
         delete_job(jenkins_url, job_name)
-    log ("Cleaned up {} builds".format(builds))
+    log ("Cleaned up {} builds.".format(builds))
 
 def cleanup(jenkins_url, builds):
-    log ("Cleaning up Jenkins")
+    log ("Cleaning up Jenkins.")
     cleanup_pipeline_jobs(jenkins_url)
     cleanup_dynamic_slaves_jobs(jenkins_url, builds)
 
 def uninstall(dcos_url, jenkins_name):
-    log ("Uninstalling Jenkins with name {}".format(jenkins_name))
+    log ("Uninstalling Jenkins with name {}.".format(jenkins_name))
     command = "dcos package uninstall --app-id={} jenkins".format(jenkins_name)
     print (command)
     if call (['dcos','package','uninstall','--app-id={}'.format(jenkins_name), 'jenkins']) != 0:
-        log ("Failed to uninstall Jenkins")
-        exit(1)
+        log_and_exit ("Failed to uninstall Jenkins.")
     log ("Jenkins has been uninstalled!")
 
 if __name__ == "__main__":
@@ -202,8 +225,8 @@ def uninstall(dcos_url, jenkins_name):
     dcos_url = arguments['<dcos_url>']
     jenkins_url = '{}service/{}/'.format(dcos_url, jenkins_name)
 
+    check_and_set_token(jenkins_url)
     config_dcos_cli(dcos_url)
-
     try:
         if arguments['install']:
             make_temp_dir()
@@ -212,8 +235,7 @@ def uninstall(dcos_url, jenkins_name):
             if not arguments['--no-pipeline']:
                 branch = arguments['--branch'].lower()
                 if branch == 'master':
-                    log("Cannot run demo against the master branch.")
-                    exit(1)
+                    log_and_exit ("Cannot run demo against the master branch.")
                 org = arguments['--org']
                 username = arguments['--username']
                 password = arguments['--password']