def new_f(*args, **kwargs):
if not "path" in kwargs:
# path = "."
path = find_git_root(os.curdir)
kwargs['path'] = path
if not "str_data" in kwargs:
yaml = os.path.join(path, DEFAULT_WERCKER_YML)
if os.path.isfile(yaml):
fh = open(yaml)
data = fh.read()
fh.close()
kwargs["str_data"] = data
else:
term = get_term()
puts("{t.red}Error:{t.normal} {yaml} not found".format(
yaml=DEFAULT_WERCKER_YML, t=term))
if not "yaml_data" in kwargs and "str_data" in kwargs:
try:
yaml_data = load(kwargs["str_data"], Loader=Loader)
except ParserError:
yaml_data = None
term = get_term()
puts(
"{t.red}Error:{t.normal} {yaml} is not formatted propery.".
format(t=term, yaml=DEFAULT_WERCKER_YML))
if type(yaml_data) is dict:
kwargs["yaml_data"] = yaml_data
return f(*args, **kwargs)
def new_f(*args, **kwargs):
if not "path" in kwargs:
# path = "."
path = find_git_root(os.curdir)
kwargs["path"] = path
if not "str_data" in kwargs:
yaml = os.path.join(path, DEFAULT_WERCKER_YML)
if os.path.isfile(yaml):
fh = open(yaml)
data = fh.read()
fh.close()
kwargs["str_data"] = data
else:
term = get_term()
puts("{t.red}Error:{t.normal} {yaml} not found".format(yaml=DEFAULT_WERCKER_YML, t=term))
if not "yaml_data" in kwargs and "str_data" in kwargs:
try:
yaml_data = load(kwargs["str_data"], Loader=Loader)
except ParserError:
yaml_data = None
term = get_term()
puts(
"{t.red}Error:{t.normal} {yaml} is not formatted propery.".format(t=term, yaml=DEFAULT_WERCKER_YML)
)
if type(yaml_data) is dict:
kwargs["yaml_data"] = yaml_data
return f(*args, **kwargs)
def project_list_queue(valid_token=None):
term = get_term()
if not valid_token:
raise ValueError("A valid token is required!")
project_id = get_value(VALUE_PROJECT_ID, print_warnings=False)
if not project_id:
puts(
term.red("Error: ") +
"No application found. Please create or link an application first"
)
return
term = get_term()
puts("Retrieving list of unfinished builds.")
result = get_builds(valid_token, project_id)
unknowns = filter(lambda r: r['result'] == "unknown", result)
print_builds(unknowns)
# print unknowns
result = get_targets(valid_token, project_id)
for target in result['data']:
# print target['id']
c = Client()
code, deploys = c.get_deploys(valid_token, target['id'])
# print result
# puts("Target: " + term.yellow(target['name']))
if 'data' in deploys:
unknowns = filter(
lambda d: d['result'] == 'unknown',
deploys['data']
)
puts(("\nFound {amount} scheduled deploys for {target}").format(
amount=len(unknowns),
target=term.white(target['name'])
))
print_deploys(unknowns)
else:
puts("\nNo scheduled deploys found.")
def project_list_queue(valid_token=None):
term = get_term()
if not valid_token:
raise ValueError("A valid token is required!")
project_id = get_value(VALUE_PROJECT_ID, print_warnings=False)
if not project_id:
puts(
term.red("Error: ") +
"No application found. Please create or link an application first"
)
return
term = get_term()
puts("Retrieving list of unfinished builds.")
result = get_builds(valid_token, project_id)
unknowns = filter(lambda r: r['result'] == "unknown", result)
print_builds(unknowns)
# print unknowns
result = get_targets(valid_token, project_id)
for target in result['data']:
# print target['id']
c = Client()
code, deploys = c.get_deploys(valid_token, target['id'])
# print result
# puts("Target: " + term.yellow(target['name']))
if 'data' in deploys:
unknowns = filter(
lambda d: d['result'] == 'unknown',
deploys['data']
)
puts(("\nFound {amount} scheduled deploys for {target}").format(
amount=len(unknowns),
target=term.white(target['name'])
))
print_deploys(unknowns)
else:
puts("\nNo scheduled deploys found.")
def list_services(path=".", yaml_data=None, str_data=None):
# pass
term = get_term()
if str_data is None:
return
if yaml_data is None:
return
services = yaml_data.get("services")
if not services:
puts(
"{t.yellow}Warning:{t.normal} No services specified in the \
{yaml}".
format(
yaml=DEFAULT_WERCKER_YML,
t=term
)
)
else:
if type(services) is str:
services = [services]
puts("Services currently in use:\n")
check_services(services)
def get_sorted_versions(box):
versions = box.get("versionNumbers", [])
sem_versions = []
rejected = []
for version in versions:
try:
sem_version = semantic_version.Version.coerce(version)
sem_versions.append(sem_version)
except ValueError:
rejected.append(version)
sem_versions = sorted(
sem_versions,
# key=lambda version: semantic_version.Version.coerce(version)
)
if len(rejected):
puts(
"{t.yellow}Warning: {t.normal}Unable to parse version values \
{versions} for {fullname}"
.format(
t=get_term(),
versions=', '.join(rejected),
fullname=box.get('fullname', '')
)
)
return sem_versions
def check_services(services):
term = get_term()
c = Client()
response, result = c.get_boxes()
for service in services:
if len(service.splitlines()) > 1:
puts("""{t.yellow}Warning:{t.normal} Incorrect service \
specification detected.
Reason: A new line detected in declaration:
{service}""".format(t=term, service=service))
else:
check_service(service, result)
# if
if services is None or len(services) == 0:
puts(
"""{t.yellow}Warning:{t.normal} No services specified in {file}"""
.format(
t=term,
file=DEFAULT_WERCKER_YML
)
)
def link_to_deploy_target(valid_token=None):
term = get_term()
if not valid_token:
raise ValueError("A valid token is required!")
project_id = get_value(VALUE_PROJECT_ID, print_warnings=False)
if not project_id:
puts(
term.red("Error: ") +
"No application found. Please create or link an application first")
return
target = pick_target(valid_token, project_id)
if not target:
return
wercker_url = get_value(VALUE_WERCKER_URL)
link = "{wercker_url}/deploytarget/{target}".format(
wercker_url=wercker_url, target=target)
puts("Opening link: {link}".format(link=link))
import webbrowser
webbrowser.open(link)
def do_get(self, path, data, display_warnings=True):
url = self.wercker_url + "/api/" + path
# data_string = json.dumps(data)
puts("communicating with %s ..." % url, level=DEBUG)
result = requests.get(
url,
params=data)
puts("done...", level=DEBUG)
status = result.status_code
result_json = {}
try:
result_json = result.json()
except ValueError:
if display_warnings:
term = get_term()
puts(
term.yellow("Warning: ") +
"Invalid response for api call: {url}".format(url=url)
)
return status, result_json
def update(current_version=None):
term = get_term()
if current_version is None:
current_version = werckercli.__version__
current_version = semver.Version(current_version)
newer_version = find_current_version(
"wercker",
current_version
)
if newer_version:
puts("""A newer version of the wercker-cli was found ({newer_version}).
Please upgrade:
""".format(newer_version=newer_version) +
term.bold_white('pip install wercker --upgrade')
)
return True
else:
puts("Current version is up-to-date ({version})".format(
version=current_version))
return False
def link_to_deploy_target(valid_token=None):
term = get_term()
if not valid_token:
raise ValueError("A valid token is required!")
project_id = get_value(VALUE_PROJECT_ID, print_warnings=False)
if not project_id:
puts(
term.red("Error: ") +
"No application found. Please create or link an application first"
)
return
target = pick_target(valid_token, project_id)
if not target:
return
wercker_url = get_value(VALUE_WERCKER_URL)
link = "{wercker_url}/deploytarget/{target}".format(
wercker_url=wercker_url,
target=target
)
puts("Opening link: {link}".format(link=link))
import webbrowser
webbrowser.open(link)
def _add_heroku_by_git(token, project_id, git_url):
term = get_term()
puts("Heroku remote %s selected." % git_url)
puts("Looking for Heroku API key...", level=DEBUG)
heroku_token = heroku.get_token()
if not heroku_token:
puts(term.red("Error: "))
# with indent(2):
puts(" Please make sure the heroku-toolbelt is installed")
puts(" and you are loged in.")
return
puts("API key found...", level=DEBUG)
puts("Retrieving applications from Heroku...", level=DEBUG)
# fp = open("werckercli/tests/data/apps.response.json")
# import json
# apps = json.load(fp)
# fp.close()
apps = heroku.get_apps()
preferred_app = None
for app in apps:
# print app
if app['git_url'] == git_url:
# print app['name']
# print app
preferred_app = app
if not preferred_app:
raise ValueError(
"No matching heroku remote repository found in the \
apps for current heroku user"
)
c = Client()
code, result = c.create_deploy_target(
token,
project_id,
preferred_app['name'],
heroku_token
)
if 'success' in result and result['success'] is True:
puts("Heroku deploy target %s \
successfully added to the wercker application\n" % preferred_app['name'])
elif result['errorMessage']:
puts(term.red("Error: ") + result['errorMessage'])
puts("Please check if the wercker addon was added to the heroku\
application or run heroku addons:add wercker")
def remove_service(
name, path=".", str_data=None, yaml_data=None
):
if str_data is None:
return
if yaml_data is None:
return
term = get_term()
current_service = yaml_data.get("services")
if current_service:
specific_service = "{name}".format(
name=name
)
service_regex = "^({service})(@)?".format(
service=specific_service
)
found = False
new_services = current_service
if type(current_service) is str:
if re.match(service_regex, current_service):
found = True
new_services = None
else:
new_services = []
for service in current_service:
if re.match(service_regex, service):
found = True
else:
new_services.append(service)
if found:
update_yaml(path, str_data, yaml_data, new_services)
puts(
"{t.green}Succes:{t.normal} Service {service} removed."
.format(
service=specific_service,
t=term,
)
)
else:
puts(
"{t.yellow}Warning: {t.normal}service {service} is not found".
format(
service=specific_service,
t=term
)
)
def get_builds(valid_token, projectId):
term = get_term()
c = Client()
puts("Retrieving builds from wercker...")
status, result = c.get_builds(valid_token, projectId)
if status != 200:
puts(
term.yellow("Warning: ") +
"A problem occurred while retrieving builds")
return result
def project_link(valid_token=None, puts_result=True, auto_link=True):
if not valid_token:
raise ValueError("A valid token is required!")
term = get_term()
if puts_result:
puts("Searching for git remote information... ")
path = find_git_root(os.curdir)
if not path:
if puts_result:
puts(term.red("error:") + " No git repository found")
return False
options = get_remote_options(path)
if options is None:
if puts_result:
puts(term.red("error:") + " No git repository found")
return False
if puts_result:
puts("Retrieving list of applications...")
c = Client()
response, result = c.get_applications(valid_token)
for option in options:
for app in result:
if convert_to_url(app['url']) == convert_to_url(option.url):
if auto_link:
set_value(VALUE_PROJECT_ID, app['id'])
if puts_result:
puts(
term.green("success:") +
" application is now linked to this repository"
)
return True
if puts_result:
puts(
"An application could " + term.white("not") +
" be linked to this repository")
return False
def print_line(list_lengths, row, props=None, line_index=0):
term = get_term()
line = u"│ "
if props:
values_list = props
else:
values_list = row
more_lines = False
for i in range(len(values_list)):
if i > 0:
line += u"│ "
if props:
try:
value = str(row[props[i]])
except KeyError:
value = u'-'
value = value
else:
value = row[i]
values = value.split("\n")
if line_index < len(values):
value = values[line_index]
if line_index + 1 < len(values):
more_lines = True
else:
value = ""
value = value.encode("utf-8")
value = value.ljust(list_lengths[i])
if value.startswith(u"passed "):
value = term.green(value)
elif value.startswith(u"failed "):
value = term.red(value)
line += value
line += u"│"
puts(line)
if more_lines:
print_line(list_lengths, row, props=props, line_index=line_index + 1)
def project_link(valid_token=None, puts_result=True, auto_link=True):
if not valid_token:
raise ValueError("A valid token is required!")
term = get_term()
if puts_result:
puts("Searching for git remote information... ")
path = find_git_root(os.curdir)
if not path:
if puts_result:
puts(term.red("error:") + " No git repository found")
return False
options = get_remote_options(path)
if options is None:
if puts_result:
puts(term.red("error:") + " No git repository found")
return False
if puts_result:
puts("Retrieving list of applications...")
c = Client()
response, result = c.get_applications(valid_token)
for option in options:
for app in result:
if convert_to_url(app['url']) == convert_to_url(option.url):
if auto_link:
set_value(VALUE_PROJECT_ID, app['id'])
if puts_result:
puts(
term.green("success:") +
" application is now linked to this repository"
)
return True
if puts_result:
puts(
"An application could " + term.white("not") +
" be linked to this repository")
return False
def get_builds(valid_token, projectId):
term = get_term()
c = Client()
puts("Retrieving builds from wercker...")
status, result = c.get_builds(valid_token, projectId)
if status != 200:
puts(
term.yellow("Warning: ") +
"A problem occurred while retrieving builds"
)
return result
def list_by_project(valid_token=None):
term = get_term()
if not valid_token:
raise ValueError("A valid token is required!")
project_id = get_value(VALUE_PROJECT_ID, print_warnings=False)
if not project_id:
puts(
term.red("Error: ") +
"No application found. Please create or link an application first")
return
targets = get_targets(valid_token, project_id)
print_targets(targets)
def _add_heroku_by_git(token, project_id, git_url):
term = get_term()
puts("Heroku remote %s selected." % git_url)
puts("Looking for Heroku API key...", level=DEBUG)
heroku_token = heroku.get_token()
if not heroku_token:
puts(term.red("Error: "))
# with indent(2):
puts(" Please make sure the heroku-toolbelt is installed")
puts(" and you are loged in.")
return
puts("API key found...", level=DEBUG)
puts("Retrieving applications from Heroku...", level=DEBUG)
# fp = open("werckercli/tests/data/apps.response.json")
# import json
# apps = json.load(fp)
# fp.close()
apps = heroku.get_apps()
preferred_app = None
for app in apps:
# print app
if app['git_url'] == git_url:
# print app['name']
# print app
preferred_app = app
if not preferred_app:
raise ValueError("No matching heroku remote repository found in the \
apps for current heroku user")
c = Client()
code, result = c.create_deploy_target(token, project_id,
preferred_app['name'], heroku_token)
if 'success' in result and result['success'] is True:
puts("Heroku deploy target %s \
successfully added to the wercker application\n" % preferred_app['name'])
elif result['errorMessage']:
puts(term.red("Error: ") + result['errorMessage'])
puts("Please check if the wercker addon was added to the heroku\
application or run heroku addons:add wercker")
def list_by_project(valid_token=None):
term = get_term()
if not valid_token:
raise ValueError("A valid token is required!")
project_id = get_value(VALUE_PROJECT_ID, print_warnings=False)
if not project_id:
puts(
term.red("Error: ") +
"No application found. Please create or link an application first"
)
return
targets = get_targets(valid_token, project_id)
print_targets(targets)
def putInfo(label, data, multiple_lines=False):
term = get_term()
paddedLabel = str(label) + ":"
paddedLabel = paddedLabel.ljust(20)
if multiple_lines is True:
seperator = "\n"
else:
seperator = ""
puts("{t.bold}{t.white}{label}{t.normal}{seperator}{data}".format(
label=paddedLabel,
seperator=seperator,
data=data,
t=term)
)
def add(valid_token=None):
term = get_term()
if not valid_token:
raise ValueError("A valid token is required!")
project_id = get_value(VALUE_PROJECT_ID, print_warnings=False)
if not project_id:
puts(
term.red("Error: ") +
"No application found. Please create or link an application first")
return
options = git.find_heroku_sources(os.curdir)
if len(options) == 0:
puts(term.red("Error: ") + "No heroku remotes found")
elif len(options) == 1:
_add_heroku_by_git(valid_token, project_id, options[0].url)
def build_list(valid_token=None, limit=5):
term = get_term()
if not valid_token:
raise ValueError("A valid token is required!")
projectId = get_value(VALUE_PROJECT_ID, print_warnings=False)
if not projectId:
puts(
term.red("Error: ") +
"No application found. Please create or link an application first")
return
builds = get_builds(valid_token, projectId)
print_builds(builds, limit=limit)
def do_login(retry_count=2):
term = get_term()
username = raw_input("username: "******"password: "******"success", False):
puts(term.green("Login successful.") + " Welcome %s!" % username)
set_value(VALUE_USER_NAME, username)
return content["result"]["token"]
elif retry_count > 0:
puts(term.yellow("Warning: ") + "Login/password incorrect, please try again.\n")
return do_login(retry_count - 1)
def add(valid_token=None):
term = get_term()
if not valid_token:
raise ValueError("A valid token is required!")
project_id = get_value(VALUE_PROJECT_ID, print_warnings=False)
if not project_id:
puts(
term.red("Error: ") +
"No application found. Please create or link an application first"
)
return
options = git.find_heroku_sources(os.curdir)
if len(options) == 0:
puts(term.red("Error: ") + "No heroku remotes found")
elif len(options) == 1:
_add_heroku_by_git(valid_token, project_id, options[0].url)
def build_list(valid_token=None, limit=5):
term = get_term()
if not valid_token:
raise ValueError("A valid token is required!")
projectId = get_value(VALUE_PROJECT_ID, print_warnings=False)
if not projectId:
puts(
term.red("Error: ") +
"No application found. Please create or link an application first"
)
return
builds = get_builds(valid_token, projectId)
print_builds(builds, limit=limit)
def _get_or_create_netrc_location():
term = get_term()
try:
file = os.path.join(os.environ['HOME'], ".netrc")
except KeyError:
raise IOError("Could not find .netrc: $HOME is not set")
if os.path.isfile(file):
result = os.stat(file)
mode = oct(stat.S_IMODE(result.st_mode))
if mode != '0600':
puts(
term.yellow('Warning:') +
'Found permission %s, on %s. It should be 0600' % (mode, file))
else:
with os.fdopen(os.open(file, os.O_APPEND | os.O_CREAT, 0o600)) as out:
out.close()
return file
def clear_settings():
term = get_term()
# home = get_global_wercker_path()
# print home
if config.get_value(config.VALUE_USER_TOKEN):
puts("""About to clear the wercker settings \
for the current user on this machine""")
sure = prompt.yn("Are you sure you want to do this?", default="n")
if sure:
# shutil.rmtree(get_global_wercker_path())
config.set_value(config.VALUE_USER_TOKEN, None)
puts(
term.green("Success: ") +
"wercker settings removed succesfully.")
return True
else:
puts(term.yellow("Warning: ") + "Cancelled.")
else:
puts(term.yellow("Warning: ") + "No settings found.")
def do_get(self, path, data, display_warnings=True):
url = self.wercker_url + "/api/" + path
puts("communicating with %s ..." % url, level=DEBUG)
result = requests.get(url, params=data)
puts("done...", level=DEBUG)
status = result.status_code
result_json = {}
try:
result_json = result.json()
except ValueError:
if display_warnings:
term = get_term()
puts(
term.yellow("Warning: ") +
"Invalid response for api call: {url}".format(url=url))
return status, result_json
def project_build(valid_token=None):
if not valid_token:
raise ValueError("A valid token is required!")
term = get_term()
puts("Triggering build")
c = Client()
code, response = c.trigger_build(valid_token, get_value(VALUE_PROJECT_ID))
if response['success'] is False:
if "errorMessage" in response:
puts(term.red("Error: ") + response['errorMessage'])
else:
puts("Unable to trigger a build on the default/master branch")
return False
else:
puts("A new build has been created")
return True
def project_build(valid_token=None):
if not valid_token:
raise ValueError("A valid token is required!")
term = get_term()
puts("Triggering a new build.")
c = Client()
code, response = c.trigger_build(valid_token, get_value(VALUE_PROJECT_ID))
if response['success'] is False:
if "errorMessage" in response:
puts(term.red("Error: ") + response['errorMessage'])
else:
puts("Unable to trigger a build on the default/master branch")
return False
else:
puts("done.")
return True
def clear_settings():
term = get_term()
# home = get_global_wercker_path()
# print home
if config.get_value(config.VALUE_USER_TOKEN):
puts(
"""About to clear the wercker settings \
for the current user on this machine"""
)
sure = prompt.yn("Are you sure you want to do this?", default="n")
if sure:
# shutil.rmtree(get_global_wercker_path())
config.set_value(config.VALUE_USER_TOKEN, None)
puts(term.green("Success: ") +
"wercker settings removed succesfully.")
return True
else:
puts(term.yellow("Warning: ") + "Cancelled.")
else:
puts(term.yellow("Warning: ") + "No settings found.")
def do_login(retry_count=2):
term = get_term()
username = raw_input("username: "******"password: "******"Login successful.") + " Welcome %s!" % username)
set_value(VALUE_USER_NAME, username)
return content['result']['token']
elif retry_count > 0:
puts(
term.yellow("Warning: ") +
"Login/password incorrect, please try again.\n")
return do_login(retry_count - 1)
def project_open():
project_id = get_value(VALUE_PROJECT_ID, print_warnings=False)
term = get_term()
if not project_id:
puts(
term.red("Error: ") +
"No application found. Please create or link an application first"
)
return
wercker_url = get_value(VALUE_WERCKER_URL)
link = "{wercker_url}/#project/{project_id}".format(
wercker_url=wercker_url,
project_id=project_id
)
puts("Opening link: {link}".format(link=link))
import webbrowser
webbrowser.open(link)
def validate():
"""
Validates the wercker.json file by doing the following:
* Check whether there is a git repository in the current directory or up.
* Check whether there is a wercker.json file in that root.
* Check whether the size of that file is greater that zero.
* Check whether the wercker.json file contains valid json.
Currently this command doesn't validate the wercker.json file against
a schema. But you can expect this in the future.
"""
term = get_term()
git_root_path = find_git_root(os.curdir)
if not git_root_path:
puts(term.red("Error: ") + "Could not find a git repository")
return
wercker_json_path = os.path.join(git_root_path, "wercker.json")
if os.path.exists(wercker_json_path) is False:
puts(term.yellow("Warning: ") + " Could not find a wercker.json file")
return
if os.path.getsize(wercker_json_path) == 0:
puts(term.red("Error: ") + "wercker.json is found, but empty")
return
try:
with open(wercker_json_path) as f:
try:
json.load(f)
puts(term.green("wercker.json is found and valid!"))
except ValueError as e:
puts(term.red("Error: ") + "wercker.json is not valid json: " +
e.message)
except IOError as e:
puts(term.red("Error: ") + "Error while reading wercker.json file: " +
e.message)
def project_open():
project_id = get_value(VALUE_PROJECT_ID, print_warnings=False)
term = get_term()
if not project_id:
puts(
term.red("Error: ") +
"No application found. Please create or link an application first"
)
return
wercker_url = get_value(VALUE_WERCKER_URL)
link = "{wercker_url}/#project/{project_id}".format(
wercker_url=wercker_url,
project_id=project_id
)
puts("Opening link: {link}".format(link=link))
import webbrowser
webbrowser.open(link)
def _get_or_create_netrc_location():
term = get_term()
try:
file = os.path.join(os.environ['HOME'], ".netrc")
except KeyError:
raise IOError("Could not find .netrc: $HOME is not set")
if os.path.isfile(file):
result = os.stat(file)
mode = oct(stat.S_IMODE(result.st_mode))
if mode != '0600':
puts(
term.yellow('Warning:') +
'Found permission %s, on %s. It should be 0600' %
(mode, file)
)
else:
with os.fdopen(os.open(file, os.O_APPEND | os.O_CREAT, 0o600)) as out:
out.close()
return file
def update(current_version=None):
term = get_term()
if current_version is None:
current_version = werckercli.__version__
current_version = semver.Version(current_version)
newer_version = find_current_version("wercker", current_version)
if newer_version:
puts("""A newer version of the wercker-cli was found ({newer_version}).
Please upgrade:
""".format(newer_version=newer_version) +
term.bold_white('pip install wercker --upgrade'))
return True
else:
puts("Current version is up-to-date ({version})".format(
version=current_version))
return False
def pick_target(valid_token, projectId):
term = get_term()
targets = get_targets(valid_token, projectId)
if not "data" in targets or len(targets['data']) == 0:
# print targets['data']
puts(term.red("No targets to deploy to were found"))
return
print_targets(targets, print_index=True)
while(True):
result = get_value_with_default("Select a target to deploy to", '1')
valid_values = [str(i + 1) for i in range(len(targets['data']))]
if result in valid_values:
target_index = valid_values.index(result)
break
else:
puts(term.yellow("Warning: ") + " invalid target selected.")
return targets['data'][target_index]['id']
def pick_target(valid_token, projectId):
term = get_term()
targets = get_targets(valid_token, projectId)
if not "data" in targets or len(targets['data']) == 0:
# print targets['data']
puts(term.red("No targets to deploy to were found"))
return
print_targets(targets, print_index=True)
while (True):
result = get_value_with_default("Select a target to deploy to", '1')
valid_values = [str(i + 1) for i in range(len(targets['data']))]
if result in valid_values:
target_index = valid_values.index(result)
break
else:
puts(term.yellow("Warning: ") + " invalid target selected.")
return targets['data'][target_index]['id']
def get_value(name, default_value=None, path=os.curdir, print_warnings=True):
value = None
term = get_term()
if name == VALUE_WERCKER_URL:
value = os.getenv("wercker_url", None)
if value is None:
value = os.getenv(ENV_KEY_WERCKER_URL, DEFAULT_WERCKER_URL)
return value
elif name == VALUE_MIXPANEL_TOKEN:
value = os.getenv(ENV_KEY_MIXPANEL_TOKEN, DEFAULT_MIXPANEL_TOKEN)
elif name == VALUE_USER_TOKEN:
wercker_url = get_value(VALUE_WERCKER_URL)
url = urlparse(wercker_url)
file = _get_or_create_netrc_location()
rc = netrc.netrc(file)
if url.hostname in rc.hosts:
value = rc.hosts[url.hostname][2]
elif name == VALUE_USER_NAME:
wercker_url = get_value(VALUE_WERCKER_URL)
url = urlparse(wercker_url)
file = _get_or_create_netrc_location()
rc = netrc.netrc(file)
if url.hostname in rc.hosts:
value = rc.hosts[url.hostname][0]
elif name == VALUE_HEROKU_TOKEN:
file = _get_or_create_netrc_location()
rc = netrc.netrc(file)
result = rc.authenticators('api.heroku.com')
if result and len(result) == 3:
value = result[2]
elif name == VALUE_PROJECT_ID:
# from paths import find_git_root
path = find_git_root(path)
if not path:
if print_warnings:
puts(
term.red("Warning:") +
" Could not find a git repository."
)
return
file = os.path.join(
path,
DEFAULT_DOT_WERCKER_NAME
)
if not os.path.isfile(file):
if print_warnings:
puts(
term.yellow("Warning:") +
" Could not find a %s file in the application root" %
DEFAULT_DOT_WERCKER_NAME
)
return
Config = ConfigParser.ConfigParser()
Config.read(file)
try:
value = Config.get('project', 'id')
except (
ConfigParser.NoOptionError,
ConfigParser.NoSectionError
):
value = None
elif name == VALUE_DISPLAY_DEBUG:
env_value = os.environ.get(ENV_KEY_DISPLAY_DEBUG)
if env_value is not None and env_value.lower() == "true":
value = True
else:
value = DEFAULT_DISPLAY_DEBUG
return value
def set_value(name, value):
term = get_term()
if name == VALUE_USER_TOKEN:
file = _get_or_create_netrc_location()
rc = netrc.netrc(file=file)
wercker_url = get_value(VALUE_WERCKER_URL)
url = urlparse(wercker_url)
if url.hostname in rc.hosts:
current_settings = rc.hosts[url.hostname]
else:
current_settings = (None, None, None)
if value is not None:
rc.hosts[url.hostname] = (
current_settings[0],
current_settings[1],
value
)
else:
rc.hosts.pop(url.hostname)
with open(file, 'w') as fp:
fp.write(str(rc))
fp.close()
elif name == VALUE_USER_NAME:
file = _get_or_create_netrc_location()
rc = netrc.netrc(file=file)
wercker_url = get_value(VALUE_WERCKER_URL)
url = urlparse(wercker_url)
if url.hostname in rc.hosts:
current_settings = rc.hosts[url.hostname]
else:
current_settings = (None, None, None)
if value is not None:
rc.hosts[url.hostname] = (
value,
current_settings[1],
current_settings[2])
else:
rc.hosts.pop(url.hostname)
with open(file, 'w') as fp:
fp.write(str(rc))
fp.close()
elif name == VALUE_PROJECT_ID:
path = find_git_root(os.curdir)
if not path:
puts(
term.red("Error:") +
" Could not find the root repository."
)
return
file = os.path.join(
path,
DEFAULT_DOT_WERCKER_NAME
)
Config = ConfigParser.ConfigParser()
if os.path.isfile(file):
Config.read(file)
if not 'project' in Config.sections():
Config.add_section('project')
fp = open(file, 'w')
Config.set('project', 'id', value)
Config.write(fp)
fp.close()
def create(path='.', valid_token=None):
if not valid_token:
raise ValueError("A valid token is required!")
term = get_term()
if get_value(VALUE_PROJECT_ID, print_warnings=False):
puts("A .wercker file was found.")
run_create = prompt.yn(
"Are you sure you want to run `wercker create`?",
default="n")
if run_create is False:
puts("Aborting.")
return
else:
puts("")
if project_link(
valid_token=valid_token,
puts_result=False,
auto_link=False
):
puts("A matching application was found on wercker.")
use_link = prompt.yn("Do you want to run 'wercker link' instead of\
`wercker create`?")
puts("")
if use_link is True:
project_link(valid_token=valid_token)
return
path = find_git_root(path)
if path:
options = get_remote_options(path)
heroku_options = filter_heroku_sources(options)
else:
options = []
heroku_options = []
if not path:
return False
puts('''About to create an application on wercker.
This consists of the following steps:
1. Validate permissions and create an application
2. Add a deploy target ({heroku_options} heroku targets detected)
3. Trigger initial build'''.format(
wercker_url=get_value(VALUE_WERCKER_URL),
heroku_options=len(heroku_options))
)
if not path:
puts(
term.red("Error:") +
" Could not find a repository." +
" wercker create requires a git repository. Create/clone a\
repository first."
)
return
options = [o for o in options if o not in heroku_options]
options = [o for o in options if o.priority > 1]
count = len(options)
puts('''
Step ''' + term.white('1') + '''.
-------------
''')
puts(
"Found %s repository location(s)...\n"
% term.white(str(count))
)
url = pick_url(options)
url = convert_to_url(url)
source = get_preferred_source_type(url)
puts("\n%s repository detected..." % source)
puts("Selected repository url is %s\n" % url)
client = Client()
code, profile = client.get_profile(valid_token)
source_type = get_source_type(url)
if source_type == SOURCE_BITBUCKET:
if profile.get('hasBitbucketToken', False) is False:
puts("No Bitbucket account linked with your profile. Wercker uses\
this connection to linkup some events for your repository on Bitbucket to our\
service.")
provider_url = get_value(
VALUE_WERCKER_URL
) + '/provider/add/cli/bitbucket'
puts("Launching {url} to start linking.".format(
url=provider_url
))
from time import sleep
sleep(5)
import webbrowser
webbrowser.open(provider_url)
raw_input("Press enter to continue...")
elif source_type == SOURCE_GITHUB:
if profile.get('hasGithubToken', False) is False:
puts("No GitHub account linked with your profile. Wercker uses\
this connection to linkup some events for your repository on GitHub to our\
service.")
provider_url = get_value(
VALUE_WERCKER_URL
) + '/provider/add/cli/github'
puts("Launching {url} to start linking.".format(
url=provider_url
))
from time import sleep
sleep(5)
import webbrowser
webbrowser.open(provider_url)
raw_input("Press enter to continue...")
puts("Creating a new application")
status, response = client.create_project(
url,
source,
valid_token
)
if response['success']:
puts("a new application has been created.")
set_value(VALUE_PROJECT_ID, response['projectId'])
puts("In the root of this repository a .wercker file has been created\
which enables the link between the source code and wercker.\n")
site_url = None
if source_type == SOURCE_GITHUB:
site_url = "https://github.com/" + \
get_username(url) + \
"/" + \
get_project(url)
elif source_type == SOURCE_BITBUCKET:
site_url = "https://bitbucket.org/" + \
get_username(url) + \
"/" + \
get_project(url)
project_check_repo(
valid_token=valid_token,
failure_confirmation=True,
site_url=site_url
)
# puts("\nSearching for deploy target information (for \
# platforms such as Heroku).")
puts('''
Step ''' + term.white('2') + '''.
-------------
''')
target_options = heroku_options
nr_targets = len(target_options)
puts("%s automatic supported target(s) found." % str(nr_targets))
if nr_targets:
target_add(valid_token=valid_token)
puts('''
Step ''' + term.white('3') + '''.
-------------
''')
project_build(valid_token=valid_token)
# if project_build(valid_token=valid_token):
# puts("To trigger a build")
# puts("")
puts('''
Done.
-------------
You are all set up to for using wercker. You can trigger new builds by
committing and pushing your latest changes.
Happy coding!''')
else:
puts(
term.red("Error: ") +
"Unable to create project. \n\nResponse: %s\n" %
(response.get('errorMessage'))
)
puts('''
Note: only repository where the wercker's user has permissions on can be added.
This is because some event hooks for wercker need to be registered on the
repository. If you want to test a public repository and don't have permissions
on it: fork it. You can add the forked repository to wercker''')
def create(path=".", valid_token=None):
if not valid_token:
raise ValueError("A valid token is required!")
term = get_term()
if get_value(VALUE_PROJECT_ID, print_warnings=False):
puts("A .wercker file was found.")
run_create = prompt.yn("Are you sure you want to run `wercker create`?", default="n")
if run_create is False:
puts("Aborting.")
return
else:
puts("")
if project_link(valid_token=valid_token, puts_result=False, auto_link=False):
puts("A matching application was found on wercker.")
use_link = prompt.yn(
"Do you want to run 'wercker link' instead of\
`wercker create`?"
)
puts("")
if use_link is True:
project_link(valid_token=valid_token)
return
path = find_git_root(path)
if path:
options = get_remote_options(path)
heroku_options = filter_heroku_sources(options)
else:
options = []
heroku_options = []
if not path:
return False
puts(
"""About to create an application on wercker.
This consists of the following steps:
1. Configure application
2. Setup keys
3. Add a deploy target ({heroku_options} heroku targets detected)
4. Trigger initial build""".format(
wercker_url=get_value(VALUE_WERCKER_URL), heroku_options=len(heroku_options)
)
)
if not path:
puts(
term.red("Error:")
+ " Could not find a repository."
+ " wercker create requires a git repository. Create/clone a\
repository first."
)
return
options = [o for o in options if o not in heroku_options]
options = [o for o in options if o.priority > 1]
count = len(options)
puts(
"""
Step """
+ term.white("1")
+ """. Configure application
-------------
"""
)
puts("%s repository location(s) found...\n" % term.bold(str(count)))
url = pick_url(options)
url = convert_to_url(url)
source = get_preferred_source_type(url)
puts("\n%s repository detected..." % source)
puts("Selected repository url is %s\n" % url)
client = Client()
code, profile = client.get_profile(valid_token)
source_type = get_source_type(url)
if source_type == SOURCE_BITBUCKET:
if profile.get("hasBitbucketToken", False) is False:
puts(
"No Bitbucket account linked with your profile. Wercker uses\
this connection to linkup some events for your repository on Bitbucket to our\
service."
)
provider_url = get_value(VALUE_WERCKER_URL) + "/provider/add/cli/bitbucket"
puts("Launching {url} to start linking.".format(url=provider_url))
from time import sleep
sleep(5)
import webbrowser
webbrowser.open(provider_url)
raw_input("Press enter to continue...")
elif source_type == SOURCE_GITHUB:
if profile.get("hasGithubToken", False) is False:
puts(
"No GitHub account linked with your profile. Wercker uses\
this connection to linkup some events for your repository on GitHub to our\
service."
)
provider_url = get_value(VALUE_WERCKER_URL) + "/provider/add/cli/github"
puts("Launching {url} to start linking.".format(url=provider_url))
from time import sleep
sleep(5)
import webbrowser
webbrowser.open(provider_url)
raw_input("Press enter to continue...")
username = get_username(url)
project = get_project(url)
puts(
"""
Step {t.white}2{t.normal}.
-------------
In order to clone the repository on wercker, an ssh key is needed. A new/unique
key can be generated for each repository. There 3 ways of using ssh keys on
wercker:
{t.green}1. Automatically add a deploy key [recommended]{t.normal}
2. Use the checkout key, wercker uses for public projects.
3. Let wercker generate a key, but allow add it manually to github/bitbucket.
(needed when using git submodules)
For more information on this see: http://etc...
""".format(
t=term
)
)
key_method = None
while True:
result = prompt.get_value_with_default("Options:", "1")
valid_values = [str(i + 1) for i in range(3)]
if result in valid_values:
key_method = valid_values.index(result)
break
else:
puts(term.red("warning: ") + " invalid build selected.")
checkout_key_id = None
checkout_key_publicKey = None
if key_method != 1:
puts("""Retrieving a new ssh-key.""")
status, response = client.create_checkout_key()
puts("done.")
if status == 200:
checkout_key_id = response["id"]
checkout_key_publicKey = response["publicKey"]
if key_method == 0:
puts("Adding deploy key to repository:")
status, response = client.link_checkout_key(
valid_token, checkout_key_id, username, project, source_type
)
if status != 200:
puts(term.red("Error:") + " uanble to add key to repository.")
sys.exit(1)
elif key_method == 2:
profile_username = profile.get("username")
status, response = client.get_profile_detailed(valid_token, profile_username)
username = response[source_type + "Username"]
url = None
if source_type == SOURCE_GITHUB:
url = "https://github.com/settings/ssh"
elif source_type == SOURCE_BITBUCKET:
url = "http://bitbucket.org/account/user/{username}/\
ssh-keys/"
if status == 200:
formatted_key = "\n".join(textwrap.wrap(checkout_key_publicKey))
puts(
"""Please add the following public key:
{publicKey}
You can add the key here: {url}\n""".format(
publicKey=formatted_key, url=url.format(username=username)
)
)
raw_input("Press enter to continue...")
else:
puts(term.red("Error:") + " unable to load wercker profile information.")
sys.exit(1)
else:
puts(term.red("Error:") + "unable to retrieve an ssh key.")
sys.exit(1)
puts("Creating a new application")
status, response = client.create_project(valid_token, username, project, source, checkout_key_id)
if response["success"]:
puts("done.\n")
set_value(VALUE_PROJECT_ID, response["data"]["id"])
puts(
"In the root of this repository a .wercker file has been created\
which enables the link between the source code and wercker.\n"
)
site_url = None
if source_type == SOURCE_GITHUB:
site_url = "https://github.com/" + username + "/" + project
elif source_type == SOURCE_BITBUCKET:
site_url = "https://bitbucket.org/" + username + "/" + project
puts(
"""
Step """
+ term.white("3")
+ """.
-------------
"""
)
target_options = heroku_options
nr_targets = len(target_options)
puts("%s automatic supported target(s) found." % str(nr_targets))
if nr_targets:
target_add(valid_token=valid_token)
puts(
"""
Step """
+ term.white("4")
+ """.
-------------
"""
)
project_build(valid_token=valid_token)
puts(
"""
Done.
-------------
You are all set up to for using wercker. You can trigger new builds by
committing and pushing your latest changes.
Happy coding!"""
)
else:
puts(term.red("Error: ") + "Unable to create project. \n\nResponse: %s\n" % (response.get("errorMessage")))
puts(
"""
Note: only repository where the wercker's user has permissions on can be added.
This is because some event hooks for wercker need to be registered on the
repository. If you want to test a public repository and don't have permissions
on it: fork it. You can add the forked repository to wercker"""
)
def set_value(name, value):
term = get_term()
if name == VALUE_USER_TOKEN:
file = _get_or_create_netrc_location()
rc = netrc.netrc(file=file)
wercker_url = get_value(VALUE_WERCKER_URL)
url = urlparse(wercker_url)
if url.hostname in rc.hosts:
current_settings = rc.hosts[url.hostname]
else:
current_settings = (None, None, None)
if value is not None:
rc.hosts[url.hostname] = (current_settings[0], current_settings[1],
value)
else:
rc.hosts.pop(url.hostname)
with open(file, 'w') as fp:
fp.write(str(rc))
fp.close()
elif name == VALUE_USER_NAME:
file = _get_or_create_netrc_location()
rc = netrc.netrc(file=file)
wercker_url = get_value(VALUE_WERCKER_URL)
url = urlparse(wercker_url)
if url.hostname in rc.hosts:
current_settings = rc.hosts[url.hostname]
else:
current_settings = (None, None, None)
if value is not None:
rc.hosts[url.hostname] = (value, current_settings[1],
current_settings[2])
else:
rc.hosts.pop(url.hostname)
with open(file, 'w') as fp:
fp.write(str(rc))
fp.close()
elif name == VALUE_PROJECT_ID:
path = find_git_root(os.curdir)
if not path:
puts(term.red("Error:") + " Could not find the root repository.")
return
file = os.path.join(path, DEFAULT_DOT_WERCKER_NAME)
Config = ConfigParser.ConfigParser()
if os.path.isfile(file):
Config.read(file)
if not 'project' in Config.sections():
Config.add_section('project')
fp = open(file, 'w')
Config.set('project', 'id', value)
Config.write(fp)
fp.close()
def create(path='.', valid_token=None):
if not valid_token:
raise ValueError("A valid token is required!")
term = get_term()
if get_value(VALUE_PROJECT_ID, print_warnings=False):
puts("A .wercker file was found.")
run_create = prompt.yn(
"Are you sure you want to run `wercker create`?",
default="n")
if run_create is False:
puts("Aborting.")
return
else:
puts("")
if project_link(
valid_token=valid_token,
puts_result=False,
auto_link=False
):
puts("A matching application was found on wercker.")
use_link = prompt.yn("Do you want to run 'wercker link' instead of\
`wercker create`?")
puts("")
if use_link is True:
project_link(valid_token=valid_token)
return
path = find_git_root(path)
if path:
options = get_remote_options(path)
heroku_options = filter_heroku_sources(options)
else:
options = []
heroku_options = []
if not path:
return False
puts('''About to create an application on wercker.
This consists of the following steps:
1. Configure application
2. Setup keys
3. Add a deploy target ({heroku_options} heroku targets detected)
4. Trigger initial build'''.format(
wercker_url=get_value(VALUE_WERCKER_URL),
heroku_options=len(heroku_options))
)
if not path:
puts(
term.red("Error:") +
" Could not find a repository." +
" wercker create requires a git repository. Create/clone a\
repository first."
)
return
options = [o for o in options if o not in heroku_options]
options = [o for o in options if o.priority > 1]
count = len(options)
puts('''
Step ''' + term.white('1') + '''. Configure application
-------------
''')
puts(
"%s repository location(s) found...\n"
% term.bold(str(count))
)
url = pick_url(options)
url = convert_to_url(url)
source = get_preferred_source_type(url)
puts("\n%s repository detected..." % source)
puts("Selected repository url is %s\n" % url)
client = Client()
code, profile = client.get_profile(valid_token)
source_type = get_source_type(url)
if source_type == SOURCE_BITBUCKET:
if profile.get('hasBitbucketToken', False) is False:
puts("No Bitbucket account linked with your profile. Wercker uses\
this connection to linkup some events for your repository on Bitbucket to our\
service.")
provider_url = get_value(
VALUE_WERCKER_URL
) + '/provider/add/cli/bitbucket'
puts("Launching {url} to start linking.".format(
url=provider_url
))
from time import sleep
sleep(5)
import webbrowser
webbrowser.open(provider_url)
raw_input("Press enter to continue...")
elif source_type == SOURCE_GITHUB:
if profile.get('hasGithubToken', False) is False:
puts("No GitHub account linked with your profile. Wercker uses\
this connection to linkup some events for your repository on GitHub to our\
service.")
provider_url = get_value(
VALUE_WERCKER_URL
) + '/provider/add/cli/github'
puts("Launching {url} to start linking.".format(
url=provider_url
))
from time import sleep
sleep(5)
import webbrowser
webbrowser.open(provider_url)
raw_input("Press enter to continue...")
username = get_username(url)
project = get_project(url)
puts('''
Step {t.white}2{t.normal}.
-------------
In order to clone the repository on wercker, an ssh key is needed. A new/unique
key can be generated for each repository. There 3 ways of using ssh keys on
wercker:
{t.green}1. Automatically add a deploy key [recommended]{t.normal}
2. Use the checkout key, wercker uses for public projects.
3. Let wercker generate a key, but allow add it manually to github/bitbucket.
(needed when using git submodules)
For more information on this see: http://etc...
'''.format(t=term))
key_method = None
while(True):
result = prompt.get_value_with_default(
"Options:",
'1'
)
valid_values = [str(i + 1) for i in range(3)]
if result in valid_values:
key_method = valid_values.index(result)
break
else:
puts(term.red("warning: ") + " invalid build selected.")
checkout_key_id = None
checkout_key_publicKey = None
if(key_method != 1):
puts('''Retrieving a new ssh-key.''')
status, response = client.create_checkout_key()
puts("done.")
if status == 200:
checkout_key_id = response['id']
checkout_key_publicKey = response['publicKey']
if key_method == 0:
puts('Adding deploy key to repository:')
status, response = client.link_checkout_key(valid_token,
checkout_key_id,
username,
project,
source_type)
if status != 200:
puts(term.red("Error:") +
" uanble to add key to repository.")
sys.exit(1)
elif key_method == 2:
profile_username = profile.get('username')
status, response = client.get_profile_detailed(
valid_token,
profile_username)
username = response[source_type + 'Username']
url = None
if source_type == SOURCE_GITHUB:
url = "https://github.com/settings/ssh"
elif source_type == SOURCE_BITBUCKET:
url = "http://bitbucket.org/account/user/{username}/\
ssh-keys/"
if status == 200:
formatted_key = "\n".join(
textwrap.wrap(checkout_key_publicKey))
puts('''Please add the following public key:
{publicKey}
You can add the key here: {url}\n'''.format(publicKey=formatted_key,
url=url.format(
username=username)))
raw_input("Press enter to continue...")
else:
puts(term.red("Error:") +
" unable to load wercker profile information.")
sys.exit(1)
else:
puts(term.red("Error:") + 'unable to retrieve an ssh key.')
sys.exit(1)
puts("Creating a new application")
status, response = client.create_project(
valid_token,
username,
project,
source,
checkout_key_id,
)
if response['success']:
puts("done.\n")
set_value(VALUE_PROJECT_ID, response['data']['id'])
puts("In the root of this repository a .wercker file has been created\
which enables the link between the source code and wercker.\n")
site_url = None
if source_type == SOURCE_GITHUB:
site_url = "https://github.com/" + \
username + \
"/" + \
project
elif source_type == SOURCE_BITBUCKET:
site_url = "https://bitbucket.org/" + \
username + \
"/" + \
project
puts('''
Step ''' + term.white('3') + '''.
-------------
''')
target_options = heroku_options
nr_targets = len(target_options)
puts("%s automatic supported target(s) found." % str(nr_targets))
if nr_targets:
target_add(valid_token=valid_token)
puts('''
Step ''' + term.white('4') + '''.
-------------
''')
project_build(valid_token=valid_token)
puts('''
Done.
-------------
You are all set up to for using wercker. You can trigger new builds by
committing and pushing your latest changes.
Happy coding!''')
else:
puts(
term.red("Error: ") +
"Unable to create project. \n\nResponse: %s\n" %
(response.get('errorMessage'))
)
puts('''
Note: only repository where the wercker's user has permissions on can be added.
This is because some event hooks for wercker need to be registered on the
repository. If you want to test a public repository and don't have permissions
on it: fork it. You can add the forked repository to wercker''')
def project_check_repo(
valid_token=None,
failure_confirmation=False,
site_url=None
):
if not valid_token:
raise ValueError("A valid token is required!")
term = get_term()
puts("Checking werckerbot permissions on the repository...")
while(True):
c = Client()
code, response = c.check_permissions(
valid_token,
get_value(VALUE_PROJECT_ID)
)
if response['success'] is True:
if response['data']['hasAccess'] is True:
puts("Werckerbot has access")
break
else:
puts("") # empty line...
if "details" in response['data']:
# puts
puts(
term.yellow("Error: ") +
response['data']['details']
)
else:
puts(
term.red("Error: ") +
"wercker's werckerbot has no access to this\
repository."
)
if failure_confirmation is True:
puts("werckerbot needs pull/read access to the repository \
to get the code.")
puts("Without access to the repository, builds and tests\
will fail.\n")
if(site_url):
puts("Go to {url} and add wercker as a collaborator\
".format(url=site_url))
exit = not prompt.yn(
"Do you want wercker to check the permissions again?",
default="y"
)
else:
exit = True
if exit:
break
else:
puts(term.red("Error: ") + "Could not validate access...")
if failure_confirmation is True:
puts("werckerbot needs pull/read access to the repository \
to get the code.")
puts("Without access to the repository, builds and tests\
will fail.\n")
if(site_url):
puts("Go to {url} and add wercker as a collaborator\
".format(url=site_url))
exit = not prompt.yn(
"Do you want wercker to check the permissions again?",
default="y"
)
else:
break
def build_deploy(valid_token=None):
if not valid_token:
raise ValueError("A valid token is required!")
term = get_term()
projectId = get_value(VALUE_PROJECT_ID, print_warnings=False)
if not projectId:
puts(
term.red("Error: ") +
"No application found. Please create or link an application first")
return
builds = get_builds(valid_token, projectId)
if type(builds) is not list or len(builds) == 0:
puts(term.yellow("warning: ") + "No builds found.")
return
passed_builds = [build for build in builds if build['result'] == "passed"]
if len(passed_builds) == 0:
puts("No passed deploys found.")
print_builds(passed_builds, print_index=True)
deploy_index = -1
target_index = -1
while (True):
result = get_value_with_default("Select which build to deploy", '1')
valid_values = [str(i + 1) for i in range(len(passed_builds))]
# valid_values = range(1, len(passed_builds) + 1)
# print valid_values, result
if result in valid_values:
deploy_index = valid_values.index(result)
break
else:
puts(term.red("warning: ") + " invalid build selected.")
target_index = pick_target(valid_token, projectId)
c = Client()
code, result = c.do_deploy(valid_token, passed_builds[deploy_index]['id'],
target_index)
if "success" in result and result['success'] is True:
puts(
term.green("Success: ") + """
Build scheduled for deploy.
You can monitor the scheduled deploy in your browser using:
{command_targets_deploy}
Or query the queue for this application using:
{command_queue}""".format(command_targets_deploy=term.white(
"wercker targets deploy"),
command_queue=term.white("wercker queue")))
else:
puts(term.red("Error: ") + "Unable to schedule deploy")
def get_value(name, default_value=None, path=os.curdir, print_warnings=True):
value = None
term = get_term()
if name == VALUE_WERCKER_URL:
value = os.getenv("wercker_url", None)
if value is None:
value = os.getenv(ENV_KEY_WERCKER_URL, DEFAULT_WERCKER_URL)
return value
elif name == VALUE_MIXPANEL_TOKEN:
value = os.getenv(ENV_KEY_MIXPANEL_TOKEN, DEFAULT_MIXPANEL_TOKEN)
elif name == VALUE_USER_TOKEN:
wercker_url = get_value(VALUE_WERCKER_URL)
url = urlparse(wercker_url)
file = _get_or_create_netrc_location()
rc = netrc.netrc(file)
if url.hostname in rc.hosts:
value = rc.hosts[url.hostname][2]
elif name == VALUE_USER_NAME:
wercker_url = get_value(VALUE_WERCKER_URL)
url = urlparse(wercker_url)
file = _get_or_create_netrc_location()
rc = netrc.netrc(file)
if url.hostname in rc.hosts:
value = rc.hosts[url.hostname][0]
elif name == VALUE_HEROKU_TOKEN:
file = _get_or_create_netrc_location()
rc = netrc.netrc(file)
result = rc.authenticators('api.heroku.com')
if result and len(result) == 3:
value = result[2]
elif name == VALUE_PROJECT_ID:
# from paths import find_git_root
path = find_git_root(path)
if not path:
if print_warnings:
puts(
term.red("Warning:") + " Could not find a git repository.")
return
file = os.path.join(path, DEFAULT_DOT_WERCKER_NAME)
if not os.path.isfile(file):
if print_warnings:
puts(
term.yellow("Warning:") +
" Could not find a %s file in the application root" %
DEFAULT_DOT_WERCKER_NAME)
return
Config = ConfigParser.ConfigParser()
Config.read(file)
try:
value = Config.get('project', 'id')
except (ConfigParser.NoOptionError, ConfigParser.NoSectionError):
value = None
elif name == VALUE_DISPLAY_DEBUG:
env_value = os.environ.get(ENV_KEY_DISPLAY_DEBUG)
if env_value is not None and env_value.lower() == "true":
value = True
else:
value = DEFAULT_DISPLAY_DEBUG
return value
def search_services(name):
client = Client()
term = get_term()
response, results = client.get_boxes()
if results and len(results):
services = filter(
lambda box: box.get("latestType", "") == "service",
results
)
services = sorted(
services,
key=lambda service: service.get("fullname")
)
if name:
services = filter(
lambda box: (
box.get("fullname", "").find(name) != -1 or
box.get("latestDescription").find(name) != -1
),
services
)
if len(services) is not 0:
if term.width:
pad_length = term.width * 0.2
pad_length = int(math.floor(pad_length))
pad_length = max(pad_length, 30)
pad_length = min(pad_length, 50)
else:
pad_length = 0
for service in services:
# versions = service.get("versionNumbers")
versions = get_sorted_versions(service)
if len(versions):
detailName = service["fullname"]
paddedName = detailName.ljust(pad_length)
if name:
paddedName = paddedName.replace(
name,
term.bold_white + name + term.normal
)
description = service["latestDescription"]
if description is None:
description = ""
version = versions[len(versions)-1]
version = str(version)
version = version.rjust(8)
if name:
description = description.replace(
name,
term.bold_white + name + term.normal
)
puts(
paddedName + " - " + version + " - " +
description
)
else:
if name:
puts(
"No services found with: {t.bold_white}{0}{t.normal}".
format(
name,
t=term
)
)
else:
puts("No services found.")
def add_service(
name, version=0, path=".", str_data=None, yaml_data=None
):
if str_data is None:
return
if yaml_data is None:
return
term = get_term()
valid = False
try:
valid = validate_box_name(name, version=version, validate_web=True)
except TransportError:
puts(
"{t.red}Error: {t.normal} An error occured while communicating \
with the server".format(t=term)
)
return
if valid is False:
if version != 0:
puts(
"""{t.red}Error: {t.normal} service {service} matching \
{version} not found.
Service not added"""
.format(
t=term,
service=name,
version=str(version)
)
)
else:
puts(
"""{t.red}Error: {t.normal} service {service} not found.
Service not added"""
.format(
t=term,
service=name,
version=str(version)
)
)
return
current_service = yaml_data.get("services")
specific_service = "{name}".format(
name=name
)
updated = False
if(version != 0):
specific_service += "@" + version
specific_regex = "^{name}(@)?".format(name=name)
if current_service:
if type(current_service) is str:
if re.match(specific_regex, current_service):
updated = True
new_services = specific_service
else:
new_services = [specific_service, current_service]
else:
new_services = []
for service in current_service:
if re.match(specific_regex, service):
updated = True
new_services.append(specific_service)
else:
new_services.append(service)
if updated is not True:
new_services.append(specific_service)
else:
new_services = specific_service
update_yaml(path, str_data, yaml_data, new_services)
if updated:
puts(
"""{t.green}Succes:{t.normal} Service {service} {t.bold_white}\
updated{t.normal} in {file}"""
.format(
t=term,
file=DEFAULT_WERCKER_YML,
service=specific_service,
)
)
else:
puts(
"""{t.green}Succes:{t.normal} Service {service} added to {file}"""
.format(
t=term,
file=DEFAULT_WERCKER_YML,
service=specific_service,
)
)
def build_deploy(valid_token=None):
if not valid_token:
raise ValueError("A valid token is required!")
term = get_term()
projectId = get_value(VALUE_PROJECT_ID, print_warnings=False)
if not projectId:
puts(
term.red("Error: ") +
"No application found. Please create or link an application first"
)
return
builds = get_builds(valid_token, projectId)
if type(builds) is not list or len(builds) == 0:
puts(term.yellow("warning: ") + "No builds found.")
return
passed_builds = [build for build in builds if build['result'] == "passed"]
if len(passed_builds) == 0:
puts("No passed deploys found.")
print_builds(passed_builds, print_index=True)
deploy_index = -1
target_index = -1
while(True):
result = get_value_with_default("Select which build to deploy", '1')
valid_values = [str(i + 1) for i in range(len(passed_builds))]
# valid_values = range(1, len(passed_builds) + 1)
# print valid_values, result
if result in valid_values:
deploy_index = valid_values.index(result)
break
else:
puts(term.red("warning: ") + " invalid build selected.")
target_index = pick_target(valid_token, projectId)
c = Client()
code, result = c.do_deploy(
valid_token,
passed_builds[deploy_index]['id'],
target_index
)
if "success" in result and result['success'] is True:
puts(term.green("Success: ") + """
Build scheduled for deploy.
You can monitor the scheduled deploy in your browser using:
{command_targets_deploy}
Or query the queue for this application using:
{command_queue}""".format(
command_targets_deploy=term.white("wercker targets deploy"),
command_queue=term.white("wercker queue")))
else:
puts(term.red("Error: ") + "Unable to schedule deploy")