Beispiel #1
0
async def _status_organization(organization_id: OrganizationID,
                               backend_addr: BackendAddr,
                               administration_token: str) -> None:
    url = backend_addr.to_http_domain_url(
        f"/administration/organizations/{organization_id}")

    rep_data = await http_request(
        url=url,
        method="GET",
        headers={"authorization": f"Bearer {administration_token}"})

    cooked_rep_data = organization_config_rep_serializer.loads(rep_data)
    for key, value in cooked_rep_data.items():
        click.echo(f"{key}: {value}")
async def create_organization_req(organization_id: OrganizationID,
                                  backend_addr: BackendAddr,
                                  administration_token: str) -> str:
    url = backend_addr.to_http_domain_url("/administration/organizations")
    data = organization_create_req_serializer.dumps(
        {"organization_id": organization_id})

    rep_data = await http_request(
        url=url,
        method="POST",
        headers={"authorization": f"Bearer {administration_token}"},
        data=data,
    )

    cooked_rep_data = organization_create_rep_serializer.loads(rep_data)
    return cooked_rep_data["bootstrap_token"]
Beispiel #3
0
async def _anonymous_cmd(serializer, addr: BackendAddr,
                         organization_id: OrganizationID, **req) -> dict:
    """
    Raises:
        BackendNotAvailable
        BackendProtocolError
    """
    logger.info("Request", cmd=req["cmd"])

    try:
        raw_req = serializer.req_dumps(req)

    except ProtocolError as exc:
        logger.exception("Invalid request data", cmd=req["cmd"], error=exc)
        raise BackendProtocolError("Invalid request data") from exc

    url = addr.to_http_domain_url(f"/anonymous/{organization_id}")
    try:
        raw_rep = await http_request(url=url, method="POST", data=raw_req)
    except OSError as exc:
        logger.debug("Request failed (backend not available)",
                     cmd=req["cmd"],
                     exc_info=exc)
        raise BackendNotAvailable(exc) from exc

    try:
        rep = serializer.rep_loads(raw_rep)

    except ProtocolError as exc:
        logger.exception("Invalid response data", cmd=req["cmd"], error=exc)
        raise BackendProtocolError("Invalid response data") from exc

    if rep["status"] == "invalid_msg_format":
        logger.error("Invalid request data according to backend",
                     cmd=req["cmd"],
                     rep=rep)
        raise BackendProtocolError("Invalid request data according to backend")

    if rep["status"] == "bad_timestamp":
        raise BackendOutOfBallparkError(rep)

    return rep