def download(self, component, artefact_name, dirpath):
""" download file from nexus
http://nexus3.sde.ttt.ru:8081/repository/PublicNorforge
/com/avaya/commons/avaya-commons-sandbox-http/1.0/
fff-commons-sandbox-http-1.0-javadoc.jar
"""
comp = NexusComponent(group=component.group,
name=component.name,
version=component.version,
classifier=component.classifier,
extension=component.extension,
repositoryName=component.repositoryName)
components = self.search(comp)
if components:
for i in components:
artefacts = self.get_artifacts(i)
for j in artefacts:
if j.name == artefact_name and\
j.classifier == component.classifier and\
j.extension == component.extension:
url = "{}/repository/{}/{}".format(
self.server_uri, component.repositoryName, j.url)
r = self._session.get(url)
# logger.debug(r.content)
logger.debug(r.status_code)
if r.status_code == 200:
file_path = os.path.join(dirpath, j.name)
with open(file_path, 'wb') as f:
f.write(r.raw.read())
return True
return False
def get_id_by_rtc_changeset(review_phase):
commands = [
{"command": logincmd,
"args": {"login": self.user, "ticket": self.token}},
{"command": cmd,
"args": {
"scmConnectionParameters": [
settings.RTC_URI,
None,
None,
],
"scmToken": "RTC",
"scmId": scm_id,
"reviewPhase": review_phase}
}]
r = requests.post(self.server_uri,
data=json.dumps(commands),
headers=self.headers)
logger.debug(r.content)
logger.debug(r.status_code)
if r.status_code is 200:
res = json.loads(r.content)
if 'errors' in r.content:
return False
elif res[1].get('result', {}).get('reviews', []):
review_id = res[1].get(
'result', {}).get('reviews', [])[0].get('reviewId')
print review_id
return review_id
return False
def show_status(self, local_workspace_dir):
"""Try to get info from local workspace
:param local_workspace_dir: path to loca dir
:return: None or data
"""
cmd = 'show status -N -j --xchangeset -d "{}"'.format(
local_workspace_dir)
out = self.__run_scm(cmd, ignore_repo=True)
logger.debug("show_status: {}".format(out))
return json.loads(out)
def list_flowtargets(self, local_workspace_dir, target):
"""List flow targets of the workspace or stream
:param local_workspace_dir: path to loca dir
:param target: name or UUID of stream or workspace
"""
cmd = 'list flowtargets -j -d "{}" "{}"'.format(
local_workspace_dir, target)
out = self.__run_scm(cmd)
logger.debug("list flowtargets: {}".format(out))
return json.loads(out)
def list_remotefiles(self, target, component, depth=1):
"""Displays the content that are in a repository workspace.
:param local_workspace_dir: path to loca dir
:param target: name or UUID of stream or workspace
:param component: name or UUID of component
:param depth: The maximum depth at which to query remote
paths.
"""
cmd = 'list remotefiles --depth {} -j -w "{}" "{}"'.format(
depth, target, component)
out = self.__run_scm(cmd)
logger.debug("list flowtargets: {}".format(out))
return json.loads(out)
def upload(self, repo, file):
""" upload file to nexus
:param str: repo - repository name
:param file: fileobj - filepath
:return: True or False
"""
with open(file, 'rb') as f:
r = requests.post("{}/{}".format(self.server_uri, repo),
auth=(self.user, self.password),
data=f)
logger.debug(r.content)
logger.debug(r.status_code)
if r.status_code == 200:
return True
return False
def get_attr(self):
base_name = os.path.basename(self.local_path)
result = re.match(
'^(?# name)(.*?)-(?=\d)(?# version)(\d.*)\.(?# extension)([^.]+)$',
base_name)
if result is None:
logger.error(
'Automatic detection of name and/or version '
'failed for %s', self.local_path)
return None, None, None
name = result.group(1)
version = result.group(2)
extension = result.group(3)
logger.debug('name: {}, version: {}, extension: {}'.format(
name, version, extension))
return name, version, extension
def run_cmd(cmd, cwd=None):
logger.debug('command: {}\n'.format(cmd))
code = None
try:
pipe = subprocess.Popen(
cmd, shell=True, cwd=cwd,
stderr=subprocess.PIPE, stdout=subprocess.PIPE)
out, err = pipe.communicate()
code = pipe.returncode
except Exception as message:
logger.debug('{}'.format(message))
raise Exception('code: {} command: {}'
'has failed with the message: {}'.format(
code, cmd, message))
if (out is None) or code != 0:
logger.debug('output before error: {}\n'.format(out))
logger.debug('code: {} and error: {}'.format(code, err))
raise Exception('Command: {} has failed with code: {} and error: {}\n'
'Output before error: {}'.format(cmd, code, err, out))
logger.debug('output: {}\n'.format(out))
return out
def create_review(self, title):
""" Create new code review
:param title: str Code review title
:return:
"""
logincmd = "SessionService.authenticate"
createcmd = "ReviewService.createReview"
deadline = datetime.datetime.now()
deadline += datetime.timedelta(days=3)
commands = [{"command": logincmd,
"args": {"login": self.user, "ticket": self.token}},
{"command": createcmd,
"args": {"creator": self.user, "title": title,
# "deadline": deadline.strftime(
# '%Y-%m-%dT%H:00:00Z'),
# "accessPolicy": "PARTICIPANTS",
"customFields": [
{"name": "Overview",
"value": ["build check: TBD\n"
"static analysis check: TBD\n"
"unit tests check: TBD\n"
"no open defect check: TBD\n"]}
]}
}]
r = requests.post(self.server_uri,
data=json.dumps(commands),
headers=self.headers)
logger.debug(r.content)
logger.debug(r.status_code)
if r.status_code is 200:
if 'reviewId' in r.content:
res = json.loads(r.content)
reviewid = [i.get('result', {}).get('reviewId')
for i in res
if i.get('result', {}).get('reviewId')][0]
logger.info("reviewid: {}".format(reviewid))
return reviewid
return None
def add_defect(self, reviewid, comment):
""" Add defect to code review
:param: reviewid - int - review ID
:param: comment - str Comment
:return: False or True
"""
logincmd = "SessionService.authenticate"
cmd = "ReviewService.createReviewDefect"
commands = [
{"command": logincmd,
"args": {"login": self.user, "ticket": self.token}},
{"command": cmd,
"args": {"reviewId": int(reviewid),
"comment": comment,
"customFields": [{"name": "Severity",
"value": ["Major"]},
{"name": "Type",
"value": ["Build"]}]
}
}]
r = requests.post(self.server_uri,
data=json.dumps(commands),
headers=self.headers)
logger.debug(r.content)
logger.debug(r.status_code)
if r.status_code is 200:
res = json.loads(r.content)
if 'defectId' in r.content:
defectid = [i.get('result', {}).get('defectId')
for i in res
if i.get('result', {}).get('defectId')][0]
logger.info("defectId: {}".format(defectid))
return defectid
if 'errors' in r.content:
logger.error("reviewid: {}"
"defectId has not been created".format(reviewid))
return False
return False
def delete_review(self, review_id):
""" Delete code review
:param review_id: int - review id
:return True or False
"""
logincmd = "SessionService.authenticate"
cmd = "ReviewService.deleteReview"
commands = [{"command": logincmd,
"args": {"login": self.user, "ticket": self.token}},
{"command": cmd,
"args": {"reviewId": int(review_id)}}]
r = requests.post(self.server_uri,
data=json.dumps(commands),
headers=self.headers)
logger.debug(r.content)
logger.debug(r.status_code)
if r.status_code is 200:
json.loads(r.content)
if 'errors' in r.content:
return False
return True
return False
def delete_defect(self, defectid):
""" Delete defect from code review
:param: defectid - int - defect ID
:return: False or True
"""
logincmd = "SessionService.authenticate"
cmd = "ReviewService.deleteDefect"
commands = [
{"command": logincmd,
"args": {"login": self.user, "ticket": self.token}},
{"command": cmd,
"args": {"defectId": int(defectid)}}]
r = requests.post(self.server_uri,
data=json.dumps(commands),
headers=self.headers)
logger.debug(r.content)
logger.debug(r.status_code)
if r.status_code is 200:
json.loads(r.content)
if 'errors' in r.content:
return False
return True
return False
def __run_scm(self, cmd, **kwargs):
"""Run command through scm
:param cmd: list - scm command
:return: object - data if successful, None otherwise
"""
ignore_r = kwargs.get('ignore_repo', False)
if not ignore_r:
if self.user and self.password:
run_cmd = "{} {} {} {} {} {} {} {}".format(
self.scm_cmd, cmd, '-r', self.repository_uri, '-u',
self.user, '-P', self.password)
else:
run_cmd = "{} {} {} {}".format(self.scm_cmd, cmd, '-r',
self.repository_uri)
else:
if self.user and self.password:
run_cmd = "{} {} {} {} {} {}".format(self.scm_cmd, cmd, '-u',
self.user, '-P',
self.password)
else:
run_cmd = "{} {}".format(self.scm_cmd, cmd)
args = shlex.split(run_cmd)
if self.password:
logger.debug(run_cmd.replace(self.password, '***'))
else:
logger.debug(run_cmd)
code = None
try:
pipe = subprocess.Popen(args,
stderr=subprocess.PIPE,
stdout=subprocess.PIPE)
out, err = pipe.communicate()
code = pipe.returncode
except Exception as message:
logger.debug('{}'.format(message))
raise Exception('code={} scm command {} '
'has failed with the '
'message: {}'.format(code, run_cmd, message))
if (out is None) or code != 0:
logger.debug("rcode ={} or err ={}".format(code, err))
raise Exception('scm command {} '
'has failed with the '
'exception: {}'.format(run_cmd, err))
return out
def add_reviewers(self, reviewid, reviewers):
""" Add more reviewers
:param: reviewid - int - review ID
:param: reviewers - list [{"user":"******", "role":"REVIEWER"}, ...]
:return: False or True
"""
logincmd = "SessionService.authenticate"
addcmd = "ReviewService.updateAssignments"
commands = [
{"command": logincmd,
"args": {"login": self.user, "ticket": self.token}},
{"command": addcmd,
"args": {"reviewId": int(reviewid), "assignments": reviewers}}]
r = requests.post(self.server_uri,
data=json.dumps(commands),
headers=self.headers)
logger.debug(r.content)
logger.debug(r.status_code)
if r.status_code is 200:
json.loads(r.content)
if 'errors' in r.content:
return False
return True
return False
def login(self):
""" Do login
:param None
:return: loginTicket or False
"""
logincmd = "SessionService.getLoginTicket"
commands = [{"command": logincmd,
"args": {"login": self.user, "password": self.password}}]
r = requests.post(self.server_uri,
data=json.dumps(commands),
headers=self.headers)
logger.debug(r.content)
logger.debug(r.status_code)
if r.status_code is 200:
res = json.loads(r.content)
token = res[0].get('result', {}).get('loginTicket')
if token:
self.token = token
return token
error_code = res[0].get('errors', {})[0].get('code')
error_mess = res[0].get('errors', {})[0].get('message')
logger.error("code: {}, message= {}".format(error_code,
error_mess))
return False
def get_artifacts(self, component):
list_artefacts = []
print "Ask{}".format(component)
headers = {
'Content-Type': 'application/json;charset=utf-8',
'Accept': '*/*',
'Accept-Encoding': 'gzip, deflate',
'X-Nexus-UI': 'true',
'X-Requested-With': 'XMLHttpRequest'
}
d = {
"action":
"coreui_Component",
"method":
"readComponentAssets",
"type":
"rpc",
"tid":
31,
"data": [{
"page":
1,
"start":
0,
"limit":
100,
"filter": [{
"property": "repositoryName",
"value": component.repositoryName
}, {
"property": "componentId",
"value": component.rid
}, {
"property": "componentName",
"value": component.name
}, {
"property": "componentGroup",
"value": component.group
}, {
"property": "componentVersion",
"value": component.version
}]
}]
}
search_url = "{}/service/extdirect".format(self.server_uri)
res = self._session.post(search_url,
headers=headers,
data=json.dumps(d))
logger.debug(res.content)
logger.debug(res.status_code)
if res.status_code == 200:
result = json.loads(res.content).get("result", {}).get("data")
if result:
for i in result:
ar = Artefact(aid=i.get('id'),
url=i.get('name'),
aformat=i.get('format'),
contentType=i.get('contentType'),
size=i.get('size'),
repositoryName=i.get('repositoryName'),
lastUpdated=i.get('lastUpdated'),
lastAccessed=i.get('lastAccessed'),
blobRef=i.get('blobRef'),
componentId=i.get('componentId'),
attributes=i.get('attributes'))
list_artefacts.append(ar)
return list_artefacts
return []
def search(self, component):
list_components = []
headers = {
'Content-Type': 'application/json;charset=utf-8',
'Accept': '*/*',
'Accept-Encoding': 'gzip, deflate',
'X-Nexus-UI': 'true',
'X-Requested-With': 'XMLHttpRequest'
}
d = {
"action":
"coreui_Search",
"method":
"read",
"type":
"rpc",
"tid":
11,
"data": [{
"page":
1,
"start":
0,
"limit":
100,
"sort": [{
"property": "group",
"direction": "ASC"
}],
"filter": [{
"property": "format",
"value": "maven2"
}, {
"property": "attributes.maven2.groupId",
"value": component.group
}, {
"property": "attributes.maven2.version",
"value": component.version
}, {
"property": "attributes.maven2.artifactId",
"value": component.name
}, {
"property": "assets.attributes.maven2.extension",
"value": component.extension
}, {
"property": "assets.attributes.maven2.classifier",
"value": component.classifier
}]
}]
}
search_url = "{}/service/extdirect".format(self.server_uri)
res = self._session.post(search_url,
headers=headers,
data=json.dumps(d))
logger.debug(res.content)
logger.debug(res.status_code)
if res.status_code == 200:
result = json.loads(res.content).get("result", {}).get("data")
if result:
for i in result:
comp = NexusComponent(
rid=i.get('id'),
group=i.get('group'),
repositoryName=i.get('repositoryName'),
name=i.get('name'),
version=i.get('version'),
cformat=i.get('format'))
list_components.append(comp)
return list_components
return []
