示例#1
0
def test_env(monkeypatch):
    monkeypatch.setenv("HTTP_PROXY", "http://this")
    monkeypatch.setenv("HTTPS_PROXY", "http://that")
    session = new_requests_session()
    assert session.proxies == {"http": "http://this", "https": "http://that"}
    session = new_requests_session(proxies=False)
    assert not session.proxies
示例#2
0
def test_env(monkeypatch):
    monkeypatch.setenv("HTTP_PROXY", "http://this")
    monkeypatch.setenv("HTTPS_PROXY", "http://that")
    session = new_requests_session()
    assert session.proxies == {"http": "http://this",
                               "https": "http://that"}
    session = new_requests_session(proxies=False)
    assert not session.proxies
示例#3
0
文件: main.py 项目: kenatbasis/devpi
 def __init__(self, args, file=None):
     self._tw = py.io.TerminalWriter(file=file)
     self.args = args
     self.cwd = py.path.local()
     self.quiet = False
     self._last_http_status = None
     self.http = new_requests_session(agent=("client", client_version))
示例#4
0
def devpiserver_on_upload_sync(log, application_url, stage, project, version):
    slack_hook = stage.ixconfig.get("slack_hook")
    if not slack_hook:
        return

    session = new_requests_session(agent=("devpi-slack", __version__))
    try:
        r = session.post(
            slack_hook,
            data={
                'payload': json.dumps({
                    "text": "Uploaded {}=={} to {}".format(
                        project,
                        version,
                        application_url
                    ),
                    "icon_url": "http://doc.devpi.net/latest/_static/devpicat.jpg",
                    "username": "******",
                })
            })
    except session.Errors:
        raise RuntimeError("%s: failed to send Slack notification %s",
                           project, slack_hook)

    if 200 <= r.status_code < 300:
        log.info("successfully sent Slack notification: %s", slack_hook)
    else:
        log.error("%s: failed to send Slack notification: %s", r.status_code,
                  slack_hook)
        log.debug(r.content)
        raise RuntimeError("%s: failed to send Slack notification: %s",
                           project, slack_hook)
示例#5
0
 def __init__(self, args, file=None):
     self._tw = py.io.TerminalWriter(file=file)
     self.args = args
     self.cwd = py.path.local()
     self.quiet = False
     self._last_http_status = None
     self.http = new_requests_session(agent=("client", client_version))
示例#6
0
文件: views.py 项目: kenatbasis/devpi
def trigger_jenkins(stage, jenkinurl, testspec):
    baseurl = get_outside_url(request.headers,
                              stage.xom.config.args.outside_url)

    source = render_string("devpibootstrap.py",
        INDEXURL=baseurl + stage.name,
        VIRTUALENVTARURL= (baseurl +
            "root/pypi/+f/3a04aa2b32c76c83725ed4d9918e362e/"
            "virtualenv-1.10.1.tar.gz"),
        TESTSPEC=testspec,
        DEVPI_INSTALL_INDEX = baseurl + stage.name + "/+simple/"
    )
    inputfile = py.io.BytesIO(source.encode("ascii"))
    req = new_requests_session(agent=("server", server_version))
    try:
        r = req.post(jenkinurl, data={
                        "Submit": "Build",
                        "name": "jobscript.py",
                        "json": json.dumps(
                    {"parameter": {"name": "jobscript.py", "file": "file0"}}),
            },
                files={"file0": ("file0", inputfile)})
    except req.RequestException:
        log.error("%s: failed to connect to jenkins at %s",
                  testspec, jenkinurl)
        return -1

    if 200 <= r.status_code < 300:
        log.info("successfully triggered jenkins: %s", jenkinurl)
    else:
        log.error("%s: failed to trigger jenkins at %s", r.status_code,
                  jenkinurl)
        return -1
示例#7
0
def test_env(monkeypatch, max_retries, retry_counter):
    monkeypatch.setenv("HTTP_PROXY", "http://this")
    monkeypatch.setenv("HTTPS_PROXY", "http://that")
    session = new_requests_session(max_retries=max_retries)
    with pytest.raises(requests.exceptions.RequestException):
        session.get("http://example.com")

    assert retry_counter.count == (max_retries or 0)
示例#8
0
 def __init__(self, args, file=None, pm=None):
     self._tw = py.io.TerminalWriter(file=file)
     self.args = args
     self.cwd = py.path.local()
     self.quiet = False
     self._last_http_stati = []
     self.http = new_requests_session(agent=("client", client_version))
     if pm is None:
         self.pm = get_pluginmanager()
     else:
         self.pm = pm
示例#9
0
 def _waitup(self, url, count=500):
     # try for 20 seconds to start devpi-server (which remotely
     # receives a serials list which may take a while)
     req = new_requests_session(proxies=False)
     while count > 0:
         try:
             req.get(url)
         except req.ConnectionError:
             time.sleep(0.1)
             count -= 1
         else:
             return True
     return False
示例#10
0
 def _waitup(self, url, count=500):
     # try for 20 seconds to start devpi-server (which remotely
     # receives a serials list which may take a while)
     req = new_requests_session(proxies=False)
     while count > 0:
         try:
             req.get(url)
         except req.ConnectionError:
             time.sleep(0.1)
             count -= 1
         else:
             return True
     return False
示例#11
0
 def _waitup(self, url, count=1800):
     # try to start devpi-server (which remotely
     # receives a serials list which may take a while)
     session = new_requests_session(proxies=False)
     while count > 0:
         try:
             session.get(url)
         except session.Errors:
             time.sleep(0.1)
             count -= 1
         else:
             return True
     return False
示例#12
0
 def _waitup(self, url, count=1800):
     # try to start devpi-server (which remotely
     # receives a serials list which may take a while)
     session = new_requests_session()
     with no_proxy(urlparse(url).netloc):
         while count > 0:
             if not self.xproc.getinfo("devpi-server").isrunning():
                 return False
             try:
                 session.get(url)
             except session.Errors:
                 time.sleep(0.1)
                 count -= 1
             else:
                 return True
     return False
示例#13
0
def test_env(monkeypatch, max_retries):
    from urllib3.util.retry import Retry
    monkeypatch.setenv("HTTP_PROXY", "http://this")
    monkeypatch.setenv("HTTPS_PROXY", "http://that")
    orig_increment = Retry.increment
    increment_retry_totals = []

    def increment(self, *args, **kwargs):
        increment_retry_totals.append(self.total)
        return orig_increment(self, *args, **kwargs)

    monkeypatch.setattr(Retry, "increment", increment)
    session = new_requests_session(max_retries=max_retries)
    with pytest.raises(requests.exceptions.RequestException):
        session.get("http://example.com")
    assert tuple(increment_retry_totals) in ((0, ), (2, 1, 0))
示例#14
0
def trigger_jenkins(request, stage, jenkinurl, testspec):
    log = request.log
    baseurl = get_outside_url(request, stage.xom.config.args.outside_url) + "/"

    source = render_string(
        "devpibootstrap.py",
        INDEXURL=baseurl + "/" + stage.name,
        VIRTUALENVTARURL=(baseurl +
                          "root/pypi/+f/d3d/915836c1ada1be731ccaa12412b98/"
                          "virtualenv-1.11.2.tar.gz", ),
        TESTSPEC=testspec,
        DEVPI_INSTALL_INDEX=baseurl + stage.name + "/+simple/")
    inputfile = py.io.BytesIO(source.encode("ascii"))
    req = new_requests_session(agent=("server", server_version))
    try:
        r = req.post(jenkinurl,
                     data={
                         "Submit":
                         "Build",
                         "name":
                         "jobscript.py",
                         "json":
                         json.dumps({
                             "parameter": {
                                 "name": "jobscript.py",
                                 "file": "file0"
                             }
                         }),
                     },
                     files={"file0": ("file0", inputfile)})
    except req.RequestException:
        log.error("%s: failed to connect to jenkins at %s", testspec,
                  jenkinurl)
        return -1

    if 200 <= r.status_code < 300:
        log.info("successfully triggered jenkins: %s", jenkinurl)
    else:
        log.error("%s: failed to trigger jenkins at %s", r.status_code,
                  jenkinurl)
        log.debug(r.content)
        return -1
示例#15
0
def devpiserver_on_upload_sync(log, application_url, stage, project, version):
    slack_hook = stage.ixconfig.get("slack_hook") or os.getenv("SLACK_HOOK")
    slack_icon = stage.ixconfig.get("slack_icon") or os.getenv(
        "SLACK_ICON", "http://doc.devpi.net/latest/_static/devpicat.jpg")
    slack_user = stage.ixconfig.get("slack_user") or os.getenv(
        "SLACK_USER", "devpi")
    if not slack_hook:
        return

    message = "Uploaded {}=={} to {}".format(project, version, application_url)
    global last_message
    if message == last_message:
        log.debug("skipping duplicate Slack notification: %s", message)
        return

    session = new_requests_session(agent=("devpi-slack", __version__))
    try:
        r = session.post(slack_hook,
                         data={
                             'payload':
                             json.dumps({
                                 "text": message,
                                 "icon_url": slack_icon,
                                 "username": slack_user,
                             })
                         })
    except session.Errors:
        raise RuntimeError("%s: failed to send Slack notification %s", project,
                           slack_hook)

    if 200 <= r.status_code < 300:
        log.info("successfully sent Slack notification: %s", slack_hook)
        last_message = message
    else:
        log.error("%s: failed to send Slack notification: %s", r.status_code,
                  slack_hook)
        log.debug(r.content.decode('utf-8'))
        raise RuntimeError("%s: failed to send Slack notification: %s",
                           project, slack_hook)
示例#16
0
def devpiserver_on_upload_sync(log, application_url, stage, project, version):
    jenkinsurl = stage.ixconfig.get("uploadtrigger_jenkins")
    if not jenkinsurl:
        return
    jenkinsurl = jenkinsurl.format(pkgname=project, pkgversion=version)

    source = render_string(
        "devpibootstrap.py",
        INDEXURL=application_url + "/" + stage.name,
        VIRTUALENVTARURL=(
            application_url +
            "/root/pypi/+f/f61/cdd983d2c4e6a/"
            "virtualenv-1.11.6.tar.gz"),
        TESTSPEC='%s==%s' % (project, version),
        DEVPI_INSTALL_INDEX=application_url + "/" + stage.name + "/+simple/")
    inputfile = py.io.BytesIO(source.encode("ascii"))
    session = new_requests_session(agent=("devpi-jenkins", __version__))
    try:
        r = session.post(
            jenkinsurl,
            data={
                "Submit": "Build",
                "name": "jobscript.py",
                "json": json.dumps({
                    "parameter": {"name": "jobscript.py", "file": "file0"}})},
            files={"file0": ("file0", inputfile)})
    except session.Errors:
        raise RuntimeError("%s: failed to connect to jenkins at %s",
                           project, jenkinsurl)

    if 200 <= r.status_code < 300:
        log.info("successfully triggered jenkins: %s", jenkinsurl)
    else:
        log.error("%s: failed to trigger jenkins at %s", r.status_code,
                  jenkinsurl)
        log.debug(r.content)
        raise RuntimeError("%s: failed to trigger jenkins at %s",
                           project, jenkinsurl)
示例#17
0
def devpiserver_on_upload_sync(log, application_url, stage, projectname, version):
    jenkinsurl = stage.ixconfig.get("uploadtrigger_jenkins")
    if not jenkinsurl:
        return
    jenkinsurl = jenkinsurl.format(pkgname=projectname, pkgversion=version)

    source = render_string(
        "devpibootstrap.py",
        INDEXURL=application_url + "/" + stage.name,
        VIRTUALENVTARURL=(
            application_url +
            "/root/pypi/+f/f61/cdd983d2c4e6a/"
            "virtualenv-1.11.6.tar.gz"),
        TESTSPEC=projectname,
        DEVPI_INSTALL_INDEX=application_url + "/" + stage.name + "/+simple/")
    inputfile = py.io.BytesIO(source.encode("ascii"))
    session = new_requests_session(agent=("devpi-jenkins", __version__))
    try:
        r = session.post(
            jenkinsurl,
            data={
                "Submit": "Build",
                "name": "jobscript.py",
                "json": json.dumps({
                    "parameter": {"name": "jobscript.py", "file": "file0"}})},
            files={"file0": ("file0", inputfile)})
    except session.Errors:
        raise RuntimeError("%s: failed to connect to jenkins at %s",
                           projectname, jenkinsurl)

    if 200 <= r.status_code < 300:
        log.info("successfully triggered jenkins: %s", jenkinsurl)
    else:
        log.error("%s: failed to trigger jenkins at %s", r.status_code,
                  jenkinsurl)
        log.debug(r.content)
        raise RuntimeError("%s: failed to trigger jenkins at %s",
                           projectname, jenkinsurl)
示例#18
0
文件: main.py 项目: kenatbasis/devpi
 def _httpsession(self):
     session = new_requests_session(agent=("server", server_version))
     return session
示例#19
0
def test_useragent():
    s = new_requests_session(agent=("hello", "1.2"))
    ua = s.headers["user-agent"]
    assert "devpi-hello/1.2" in ua
    assert sys.version.split()[0] in ua
    assert "*" not in ua
示例#20
0
def test_env(monkeypatch):
    monkeypatch.setenv("HTTP_PROXY", "http://this")
    monkeypatch.setenv("HTTPS_PROXY", "http://that")
    session = new_requests_session()
    with pytest.raises(requests.exceptions.ProxyError):
        session.get("http://example.com")
示例#21
0
def test_useragent():
    s = new_requests_session(agent=("hello", "1.2"))
    ua = s.headers["user-agent"]
    assert "devpi-hello/1.2" in ua
    assert sys.version.split()[0] in ua
    assert "*" not in ua
示例#22
0
    def pushrelease(self):
        request = self.request
        stage = self.context.stage
        pushdata = getjson(request)
        try:
            name = pushdata["name"]
            version = pushdata["version"]
        except KeyError:
            apireturn(400, message="no name/version specified in json")

        # first, get all the links related to the source "to push" release
        try:
            linkstore = stage.get_linkstore_perstage(name, version)
        except stage.MissesRegistration:
            apireturn(
                400, "there are no files for %s-%s on stage %s" %
                (name, version, stage.name))
        links = dict([(rel, linkstore.get_links(rel=rel))
                      for rel in ('releasefile', 'doczip', 'toxresult')])
        if not links["releasefile"]:
            self.log.info("%s: no release files for version %s-%s" %
                          (stage.name, name, version))
            apireturn(404,
                      message="no release/files found for %s-%s" %
                      (name, version))

        metadata = get_pure_metadata(linkstore.verdata)

        # prepare metadata for submission
        metadata[":action"] = "submit"

        results = []
        targetindex = pushdata.get("targetindex", None)
        if targetindex is not None:  # in-server push
            parts = targetindex.split("/")
            if len(parts) != 2:
                apireturn(400, message="targetindex not in format user/index")
            target_stage = self.context.getstage(*parts)
            auth_user = request.authenticated_userid
            self.log.debug("targetindex %r, auth_user %r", targetindex,
                           auth_user)
            if not target_stage.can_upload(auth_user):
                apireturn(401,
                          message="user %r cannot upload to %r" %
                          (auth_user, targetindex))
            self._set_versiondata_dict(target_stage, metadata)
            results.append(
                (200, "register", name, version, "->", target_stage.name))
            results.extend(self._push_links(links, target_stage, name,
                                            version))
            apireturn(200, result=results, type="actionlog")
        else:
            posturl = pushdata["posturl"]
            username = pushdata["username"]
            password = pushdata["password"]
            pypiauth = (username, password)
            self.log.info("registering %s-%s to %s", name, version, posturl)
            session = new_requests_session(agent=("server", server_version))
            r = session.post(posturl, data=metadata, auth=pypiauth)
            self.log.debug("register returned: %s", r.status_code)
            ok_codes = (200, 201)
            results.append((r.status_code, "register", name, version))
            if r.status_code in ok_codes:
                for link in links["releasefile"]:
                    entry = link.entry
                    file_metadata = metadata.copy()
                    file_metadata[":action"] = "file_upload"
                    basename = link.basename
                    pyver, filetype = get_pyversion_filetype(basename)
                    file_metadata["filetype"] = filetype
                    file_metadata["pyversion"] = pyver
                    content = entry.file_get_content()
                    self.log.info("sending %s to %s, metadata %s", basename,
                                  posturl, file_metadata)
                    r = session.post(posturl,
                                     data=file_metadata,
                                     auth=pypiauth,
                                     files={"content": (basename, content)})
                    self.log.debug("send finished, status: %s", r.status_code)
                    results.append(
                        (r.status_code, "upload", entry.relpath, r.text))
                if links["doczip"]:
                    doc_metadata = metadata.copy()
                    doc_metadata[":action"] = "doc_upload"
                    doczip = links["doczip"][0].entry.file_get_content()
                    r = session.post(
                        posturl,
                        data=doc_metadata,
                        auth=pypiauth,
                        files={"content": (name + ".zip", doczip)})
                    self.log.debug("send finished, status: %s", r.status_code)
                    results.append((r.status_code, "docfile", name))
                #
            if r.status_code in ok_codes:
                apireturn(200, result=results, type="actionlog")
            else:
                apireturn(502, result=results, type="actionlog")
示例#23
0
from __future__ import print_function
from __future__ import unicode_literals

import os

from requests.exceptions import HTTPError

from devpi_server.log import threadlog
import devpi_server
from devpi_common.request import new_requests_session
from devpi_server.extpypi import IndexParser, URL

server_version = devpi_server.__version__
session = new_requests_session(agent=("server", server_version))


def devpiserver_get_projectname(stage, name):
    print('*** devpiserver_get_projectname: stage.name=%r; name=%r'
          % (stage.name, name))
    try:
        cheeseprism_data = get_data_from_cheeseprism(name)
    except HTTPError:
        # Try querying on normalized (lowercased) name
        try:
            cheeseprism_data = get_data_from_cheeseprism(name.lower())
        except HTTPError:
            return None
        else:
            return cheeseprism_data[0]['name']
    else:
        return cheeseprism_data[0]['name']
示例#24
0
文件: main.py 项目: kenatbasis/devpi
 def _httpsession(self):
     session = new_requests_session(agent=("server", server_version))
     return session
示例#25
0
文件: main.py 项目: t-8ch/devpi
 def new_http_session(self, component_name):
     session = new_requests_session(agent=(component_name, server_version))
     session.cert = self.config.args.replica_cert
     return session
示例#26
0
def test_env(monkeypatch):
    monkeypatch.setenv("HTTP_PROXY", "http://this")
    monkeypatch.setenv("HTTPS_PROXY", "http://that")
    session = new_requests_session()
    with pytest.raises(requests.exceptions.ProxyError):
        session.get("http://example.com")
示例#27
0
文件: views.py 项目: kenatbasis/devpi
    def pushrelease(self, user, index):
        stage = self.getstage(user, index)
        pushdata = getjson(request)
        try:
            name = pushdata["name"]
            version = pushdata["version"]
        except KeyError:
            apireturn(400, message="no name/version specified in json")

        projectconfig = stage.get_projectconfig(name)
        matches = []
        if projectconfig:
            verdata = projectconfig.get(version)
            if verdata:
                files = verdata.get("+files")
                for basename, relpath in files.items():
                    entry = stage.xom.filestore.getentry(relpath)
                    if not entry.iscached():
                        abort(400, "cannot push non-cached files")
                    matches.append(entry)
                metadata = get_pure_metadata(verdata)

        if not matches:
            log.info("%s: no release files %s-%s" %(stage.name, name, version))
            apireturn(404,
                      message="no release/files found for %s-%s" %(
                      name, version))

        doczip = stage.get_doczip(name, version)

        # prepare metadata for submission
        metadata[":action"] = "submit"

        results = []
        targetindex = pushdata.get("targetindex", None)
        if targetindex is not None:
            parts = targetindex.split("/")
            if len(parts) != 2:
                apireturn(400, message="targetindex not in format user/index")
            target_stage = self.getstage(*parts)
            auth_user = self.auth.get_auth_user(request.auth, raising=False)
            log.debug("targetindex %r, auth_user %r", targetindex, auth_user)
            if not target_stage.can_upload(auth_user):
               apireturn(401, message="user %r cannot upload to %r"
                                      %(auth_user, targetindex))
            #results = stage.copy_release(metadata, target_stage)
            #results.append((r.status_code, "upload", entry.relpath))
            #apireturn(200, results=results, type="actionlog")
            if not target_stage.get_metadata(name, version):
                self._register_metadata_dict(target_stage, metadata)
            results.append((200, "register", name, version,
                            "->", target_stage.name))
            for entry in matches:
                res = target_stage.store_releasefile(
                    entry.basename, entry.FILE.filepath.read(mode="rb"))
                if not isinstance(res, int):
                    res = 200
                results.append((res, "store_releasefile", entry.basename,
                                "->", target_stage.name))
            if doczip:
                target_stage.store_doczip(name, version, doczip)
                results.append((200, "uploaded documentation", name,
                                "->", target_stage.name))
            apireturn(200, result=results, type="actionlog")
        else:
            posturl = pushdata["posturl"]
            username = pushdata["username"]
            password = pushdata["password"]
            pypiauth = (username, password)
            log.info("registering %s-%s to %s", name, version, posturl)
            session = new_requests_session(agent=("server", server_version))
            r = session.post(posturl, data=metadata, auth=pypiauth)
            log.debug("register returned: %s", r.status_code)
            ok_codes = (200, 201)
            results.append((r.status_code, "register", name, version))
            if r.status_code in ok_codes:
                for entry in matches:
                    file_metadata = metadata.copy()
                    file_metadata[":action"] = "file_upload"
                    basename = entry.basename
                    pyver, filetype = get_pyversion_filetype(basename)
                    file_metadata["filetype"] = filetype
                    file_metadata["pyversion"] = pyver
                    openfile = entry.FILE.filepath.open("rb")
                    log.info("sending %s to %s, metadata %s",
                             basename, posturl, file_metadata)
                    r = session.post(posturl, data=file_metadata,
                          auth=pypiauth,
                          files={"content": (basename, openfile)})
                    log.debug("send finished, status: %s", r.status_code)
                    results.append((r.status_code, "upload", entry.relpath,
                                    r.content))
                if doczip:
                    doc_metadata = metadata.copy()
                    doc_metadata[":action"] = "doc_upload"
                    r = session.post(posturl, data=doc_metadata,
                          auth=pypiauth,
                          files={"content": (name + ".zip", doczip)})
                    log.debug("send finished, status: %s", r.status_code)
                    results.append((r.status_code, "docfile", name))
                #
            if r.status_code in ok_codes:
                apireturn(200, result=results, type="actionlog")
            else:
                apireturn(502, result=results, type="actionlog")
示例#28
0
文件: extpypi.py 项目: t-8ch/devpi
 def __init__(self, url):
     self._url = url
     self._session = new_requests_session(agent=("server", server_version))
     self._session.headers["content-type"] = "text/xml"
     self._session.headers["Accept"] = "text/xml"
示例#29
0
文件: views.py 项目: kenatbasis/devpi
    def pushrelease(self, user, index):
        stage = self.getstage(user, index)
        pushdata = getjson(request)
        try:
            name = pushdata["name"]
            version = pushdata["version"]
        except KeyError:
            apireturn(400, message="no name/version specified in json")

        projectconfig = stage.get_projectconfig(name)
        matches = []
        if projectconfig:
            verdata = projectconfig.get(version)
            if verdata:
                files = verdata.get("+files")
                for basename, relpath in files.items():
                    entry = stage.xom.filestore.getentry(relpath)
                    if not entry.iscached():
                        abort(400, "cannot push non-cached files")
                    matches.append(entry)
                metadata = get_pure_metadata(verdata)

        if not matches:
            log.info("%s: no release files %s-%s" %
                     (stage.name, name, version))
            apireturn(404,
                      message="no release/files found for %s-%s" %
                      (name, version))

        doczip = stage.get_doczip(name, version)

        # prepare metadata for submission
        metadata[":action"] = "submit"

        results = []
        targetindex = pushdata.get("targetindex", None)
        if targetindex is not None:
            parts = targetindex.split("/")
            if len(parts) != 2:
                apireturn(400, message="targetindex not in format user/index")
            target_stage = self.getstage(*parts)
            auth_user = self.auth.get_auth_user(request.auth, raising=False)
            log.debug("targetindex %r, auth_user %r", targetindex, auth_user)
            if not target_stage.can_upload(auth_user):
                apireturn(401,
                          message="user %r cannot upload to %r" %
                          (auth_user, targetindex))
            #results = stage.copy_release(metadata, target_stage)
            #results.append((r.status_code, "upload", entry.relpath))
            #apireturn(200, results=results, type="actionlog")
            if not target_stage.get_metadata(name, version):
                self._register_metadata_dict(target_stage, metadata)
            results.append(
                (200, "register", name, version, "->", target_stage.name))
            for entry in matches:
                res = target_stage.store_releasefile(
                    entry.basename, entry.FILE.filepath.read(mode="rb"))
                if not isinstance(res, int):
                    res = 200
                results.append((res, "store_releasefile", entry.basename, "->",
                                target_stage.name))
            if doczip:
                target_stage.store_doczip(name, version, doczip)
                results.append((200, "uploaded documentation", name, "->",
                                target_stage.name))
            apireturn(200, result=results, type="actionlog")
        else:
            posturl = pushdata["posturl"]
            username = pushdata["username"]
            password = pushdata["password"]
            pypiauth = (username, password)
            log.info("registering %s-%s to %s", name, version, posturl)
            session = new_requests_session(agent=("server", server_version))
            r = session.post(posturl, data=metadata, auth=pypiauth)
            log.debug("register returned: %s", r.status_code)
            ok_codes = (200, 201)
            results.append((r.status_code, "register", name, version))
            if r.status_code in ok_codes:
                for entry in matches:
                    file_metadata = metadata.copy()
                    file_metadata[":action"] = "file_upload"
                    basename = entry.basename
                    pyver, filetype = get_pyversion_filetype(basename)
                    file_metadata["filetype"] = filetype
                    file_metadata["pyversion"] = pyver
                    openfile = entry.FILE.filepath.open("rb")
                    log.info("sending %s to %s, metadata %s", basename,
                             posturl, file_metadata)
                    r = session.post(posturl,
                                     data=file_metadata,
                                     auth=pypiauth,
                                     files={"content": (basename, openfile)})
                    log.debug("send finished, status: %s", r.status_code)
                    results.append(
                        (r.status_code, "upload", entry.relpath, r.content))
                if doczip:
                    doc_metadata = metadata.copy()
                    doc_metadata[":action"] = "doc_upload"
                    r = session.post(
                        posturl,
                        data=doc_metadata,
                        auth=pypiauth,
                        files={"content": (name + ".zip", doczip)})
                    log.debug("send finished, status: %s", r.status_code)
                    results.append((r.status_code, "docfile", name))
                #
            if r.status_code in ok_codes:
                apireturn(200, result=results, type="actionlog")
            else:
                apireturn(502, result=results, type="actionlog")
示例#30
0
文件: views.py 项目: uceo/uceo-2015
    def pushrelease(self):
        request = self.request
        stage = self.context.stage
        pushdata = getjson(request)
        try:
            name = pushdata["name"]
            version = pushdata["version"]
        except KeyError:
            apireturn(400, message="no name/version specified in json")

        # first, get all the links related to the source "to push" release
        try:
            linkstore = stage.get_linkstore_perstage(name, version)
        except stage.MissesRegistration:
            apireturn(400, "there are no files for %s-%s on stage %s" %(
                           name, version, stage.name))
        links = dict([(rel, linkstore.get_links(rel=rel))
                        for rel in ('releasefile', 'doczip', 'toxresult')])
        if not links["releasefile"]:
            self.log.info("%s: no release files for version %s-%s" %
                          (stage.name, name, version))
            apireturn(404, message="no release/files found for %s-%s" %(
                      name, version))

        metadata = get_pure_metadata(linkstore.verdata)

        results = []
        targetindex = pushdata.get("targetindex", None)
        if targetindex is not None:  # in-server push
            parts = targetindex.split("/")
            if len(parts) != 2:
                apireturn(400, message="targetindex not in format user/index")
            target_stage = self.context.getstage(*parts)
            auth_user = request.authenticated_userid
            self.log.debug("targetindex %r, auth_user %r", targetindex,
                           auth_user)
            if not request.has_permission("pypi_submit", context=target_stage):
               apireturn(401, message="user %r cannot upload to %r"
                                      %(auth_user, targetindex))
            self._set_versiondata_dict(target_stage, metadata)
            results.append((200, "register", name, version,
                            "->", target_stage.name))
            try:
                results.extend(self._push_links(links, target_stage, name, version))
            except target_stage.NonVolatile as e:
                apireturn(409, "%s already exists in non-volatile index" % (
                          e.link.basename,))
            apireturn(200, result=results, type="actionlog")
        else:
            posturl = pushdata["posturl"]
            username = pushdata["username"]
            password = pushdata["password"]
            pypiauth = (username, password)
            # prepare metadata for submission
            metadata[":action"] = "submit"
            self.log.info("registering %s-%s to %s", name, version, posturl)
            session = new_requests_session(agent=("server", server_version))
            r = session.post(posturl, data=metadata, auth=pypiauth)
            self.log.debug("register returned: %s", r.status_code)
            ok_codes = (200, 201)
            results.append((r.status_code, "register", name, version))
            if r.status_code in ok_codes:
                for link in links["releasefile"]:
                    entry = link.entry
                    file_metadata = metadata.copy()
                    file_metadata[":action"] = "file_upload"
                    basename = link.basename
                    pyver, filetype = get_pyversion_filetype(basename)
                    file_metadata["filetype"] = filetype
                    file_metadata["pyversion"] = pyver
                    content = entry.file_get_content()
                    self.log.info("sending %s to %s, metadata %s",
                             basename, posturl, file_metadata)
                    r = session.post(posturl, data=file_metadata,
                          auth=pypiauth,
                          files={"content": (basename, content)})
                    self.log.debug("send finished, status: %s", r.status_code)
                    results.append((r.status_code, "upload", entry.relpath,
                                    r.text))
                if links["doczip"]:
                    doc_metadata = metadata.copy()
                    doc_metadata[":action"] = "doc_upload"
                    doczip = links["doczip"][0].entry.file_get_content()
                    r = session.post(posturl, data=doc_metadata,
                          auth=pypiauth,
                          files={"content": (name + ".zip", doczip)})
                    self.log.debug("send finished, status: %s", r.status_code)
                    results.append((r.status_code, "docfile", name))
                #
            if r.status_code in ok_codes:
                apireturn(200, result=results, type="actionlog")
            else:
                apireturn(502, result=results, type="actionlog")
示例#31
0
def test_exception_attributes():
    session = new_requests_session()
    assert isinstance(session.Errors, tuple)
示例#32
0
 def __init__(self, current):
     self.current = current
     self.requests = new_requests_session(agent=("client", client_version))
示例#33
0
 def new_http_session(self, component_name):
     session = new_requests_session(agent=(component_name, server_version))
     session.cert = self.config.args.replica_cert
     return session
示例#34
0
文件: main.py 项目: traverseda/devpi
 def new_http_session(self, component_name, max_retries=None):
     session = new_requests_session(agent=(component_name, server_version), max_retries=max_retries)
     session.cert = self.config.replica_cert
     return session
示例#35
0
文件: extpypi.py 项目: uceo/uceo-2015
 def __init__(self, url):
     self._url = url
     self._session = new_requests_session(agent=("server", server_version))
     self._session.headers["content-type"] = "text/xml"
     self._session.headers["Accept"] = "text/xml"