Exemplo n.º 1
0
def merge_request_create_deploy(project_id, merge_request_id):
    files = json_loads(request.params.get('files'))
    setting = json_loads(request.params.get('setting'))
    deploy_file_header = DeployFileHeader(setting.get('group'),
                                          setting.get('profile'))
    deploy_xml = CreateDeployFileXmlOld(files, deploy_file_header)
    return json.JSONEncoder().encode(deploy_xml.create())
Exemplo n.º 2
0
            def handle_rpc():
                json_body = {}
                try:
                    if bottle.request.headers['CONTENT_TYPE'] \
                       not in ('application/json', 'application/json-rpc'):
                        raise ParseError(
                            message='Invalid content type.',
                            data=bottle.request.headers['CONTENT_TYPE'])
                    try:
                        json_body = bottle.json_loads(
                            bottle.request.body.read())
                    except ValueError as err:
                        raise ParseError(
                            message='Invalid JSON.',
                            data=json.dumps(traceback.format_exc()))

                    response = self._endpoint.rpc(json_body)
                    # If we have error set the HTTP status code
                    if 'error' in response:
                        error = response['error']
                        status = jsonrpc_code_to_status.get(error['code'], 500)
                        bottle.response.status = status

                    return response
                except JsonRpcError as err:
                    return jsonrpc_message({
                        'id': json_body.get('id'),
                        'error': err.to_json()
                    })
Exemplo n.º 3
0
def merge_request_rollback_files(project_id, merge_request_id):
    REQUESTS.labels(method='POST', endpoint="merge_request_change_files").inc()
    files = json_loads(request.params.get('files'))
    with gitlab.Gitlab.from_config('home', ['config/gitlab.ini']) as gl:
        project = gl.projects.get(project_id)
        deploy_xml = CreateDeployFileSql(files, project, merge_request_id)
        return json.JSONEncoder().encode(deploy_xml.rollback())
Exemplo n.º 4
0
def do_work():
    context = zmq.Context()
    receiver = context.socket(zmq.SUB)
    receiver.connect('tcp://localhost:{}'.format(ZEROMQ_PORT))
    receiver.setsockopt(zmq.SUBSCRIBE, '')
    externalapi = ExternalApi('http://45.55.88.99:99/api/', 'nota', 'yu', 'yu')
    print 'worker ready'

    while True:
        s = receiver.recv_pyobj()
        if s.command == Command.SAVE:
            with open(s.path) as f:
                data = json_loads(f.read())
                options = InvoiceOptions()
                options.incrementar_codigo = False
                options.revisar_producto = False
                options.crear_cliente = True
                data['options'] = options
                del data.timestamp
                serialized = json_dumps(data.serialize())
                codigo = externalapi.save(serialized).json()['codigo']
                with sessionmanager as session:
                    session.query(NPedidoTemporal).filter_by(
                        id=s.uid).update({
                            NPedidoTemporal.status: 'uploaded',
                            NPedidoTemporal.external_id: codigo})
                    session.flush()
        elif s.command == Command.COMMIT:
            t = Invoice(InvMetadata, [])
            with sessionmanager as session:
                temp = session.query(NPedidoTemporal).filter_by(id=s.uid).first()
                if temp.external_id is not None:
                    t.meta.uid = temp.external_id
                    externalapi.commit(t)
Exemplo n.º 5
0
            def handle_rpc():
                json_body = {}
                try:
                    if bottle.request.headers['CONTENT_TYPE'] \
                       not in ('application/json', 'application/json-rpc'):
                        raise ParseError(
                            message='Invalid content type.',
                            data=bottle.request.headers['CONTENT_TYPE'])
                    try:
                        json_body = bottle.json_loads(
                            bottle.request.body.read())
                    except ValueError as err:
                        raise ParseError(message='Invalid JSON.',
                                         data=json.dumps(
                                             traceback.format_exc()))

                    response = self._endpoint.rpc(json_body)
                    # If we have error set the HTTP status code
                    if 'error' in response:
                        error = response['error']
                        status = jsonrpc_code_to_status.get(error['code'], 500)
                        bottle.response.status = status

                    return response
                except JsonRpcError as err:
                    return jsonrpc_message({
                        'id': json_body.get('id'),
                        'error': err.to_json()
                    })
Exemplo n.º 6
0
 def load(self):
     if path.exists(self.filename):
         try:
             with open(self.filename) as fp:
                 json = fp.read()
                 self.data.update(json_loads(json))
         except Exception as ex:
             logger.error("Failed reading config file: " + str(ex))
             self.data = {}
def kv_store_get_prefix(connection, prefix_name, limit=None, offset=None):
    assert isinstance(prefix_name, str)
    clause, params = limit_offset_helper(limit,
                                         offset,
                                         order_by="keyName",
                                         extra_params={"prefix": prefix_name})
    with cursor_manager(connection) as c:
        c.execute(
            """
            SELECT keyName, value FROM keyValueStore WHERE keyName LIKE :prefix || '%'
            """ + clause, params)
        return [(r['keyName'], json_loads(r['value'])) for r in c.fetchall()]
def kv_store_get(connection, key_name, default=None):
    assert isinstance(key_name, str)
    with cursor_manager(connection) as c:
        c.execute(
            """
            SELECT value FROM keyValueStore WHERE keyName=?
            """, (key_name, ))
        row = c.fetchone()
        if row is None:
            return default
        else:
            return json_loads(row['value'])
Exemplo n.º 9
0
 def parseJson(self, rep):
     if 'AJAX Error' in rep:
         html = self.load(self.pyfile.url, decode=True)
         m = re.search(r"waitingtime = (\d+);", html)
         if m:
             seconds = int(m.group(1))
             self.logDebug("You have to wait %d seconds between free downloads" % seconds)
             self.retry(wait_time=seconds)
         else:
             self.error(_("Unable to detect wait time between free downloads"))
     elif 'Hash expired' in rep:
         self.retry(reason=_("Hash expired"))
     return json_loads(rep)
Exemplo n.º 10
0
def get_stateful_info():
    """Endpoint to get access the changing properties of the device
    Local Time
    Uptime
    memory
    """
    try:
        ubus_process = run(["ubus", "call", "system", "info"], stdout=PIPE, stderr=PIPE, timeout=5, check=False)
        system_json = json_loads(ubus_process.stdout)
        return {"info": system_json}
    except JSONDecodeError:
        response.status = 400
        return "Error getting information"
Exemplo n.º 11
0
    def addGraphParts(self, sessionId):
        if bottle.request.content_type != 'application/json':
            bottle.response.status = 415
            return

        # We also accept gzipped content
        hdrs = bottle.request.headers
        if hdrs.get('Content-Encoding', None) == 'gzip':
            json_content = utils.ZlibUncompressedStream(bottle.request.body)
        else:
            json_content = bottle.request.body

        graph_parts = bottle.json_loads(json_content.read())
        self.dm.addGraphSpec(sessionId, graph_parts)
Exemplo n.º 12
0
 def parseJson(self, rep):
     if 'AJAX Error' in rep:
         html = self.load(self.pyfile.url, decode=True)
         m = re.search(r"waitingtime = (\d+);", html)
         if m:
             seconds = int(m.group(1))
             self.logDebug(
                 "You have to wait %d seconds between free downloads" %
                 seconds)
             self.retry(wait_time=seconds)
         else:
             self.error(
                 _("Unable to detect wait time between free downloads"))
     elif 'Hash expired' in rep:
         self.retry(reason=_("Hash expired"))
     return json_loads(rep)
Exemplo n.º 13
0
def get_generic_info(uci, uci_rom):
    """Endpoint to get access the fixed properties of the device
    Model
    Kernel
    Hostname
    Mac Addresses
    Firmware Version: current, reset and new
    API Version
    admin-interface Version
    Ports
    """
    try:
        ubus_process = run(["ubus", "call", "system", "board"], stdout=PIPE, stderr=PIPE, timeout=5, check=False)
        system_json = json_loads(ubus_process.stdout)
        model = getenv("DEVICE_PRODUCT", "InvizBox 2")
        try:
            admin_interface_version = ''
            with open("/usr/lib/opkg/info/admin-interface.control", encoding="utf-8") as admin_interface_file:
                for line in admin_interface_file.readlines():
                    if line.startswith("Version:"):
                        admin_interface_version = line.strip().split()[1].replace('-', '.')
                        break
        except FileNotFoundError:
            pass
        firmware_version = get_uci_info(uci, UPDATE_PKG, "version", "firmware")
        rom_firmware_version = get_uci_info(uci_rom, UPDATE_PKG, "version", "firmware")
        new_firmware_version = get_uci_info(uci, UPDATE_PKG, "version", "new_firmware")
        api_version = get_uci_info(uci, REST_API_PKG, "version", "api")
        ports = ["LAN"]
        if model == "InvizBox 2 Pro":
            ports = ["1", "2", "3", "4"]
        if model == "InvizBox Go":
            ports = []
        return {"info": {"currentFirmware": firmware_version,
                         "resetFirmware": rom_firmware_version,
                         "newFirmware": new_firmware_version,
                         "api": api_version,
                         "adminInterface": admin_interface_version,
                         "kernel": system_json["kernel"],
                         "hostName": system_json["hostname"],
                         "model": model,
                         "ports": ports}}
    except JSONDecodeError:
        response.status = 400
        return "Error getting information"
Exemplo n.º 14
0
def auth_code(code:str, redirec_page:str) -> (str, int, str):
    url = "https://oauth.vk.com/access_token?client_id={0}&client_secret={1}&code={2}&redirect_uri=http://{3}:{4}" + redirec_page
    url = url.format(config.vk.appid, config.vk.secret, code, config.server.ip, config.server.port)
    try:
        response = urllib.request.urlopen(url)
    except Exception as e:
        e = ValueError()
        e.vkerror = dict()
        e.vkerror['error'] = "Auth error"
        e.vkerror['error_description'] = "Unauthorized"
        raise e
    response = response.read().decode()
    response = bottle.json_loads(response)
    if 'error' in response:
        e = ValueError()
        e.vkerror = response
        raise e
    return response['access_token'], response['user_id'], response.get('email')
Exemplo n.º 15
0
    def addGraphParts(self, sessionId):
        # WARNING: TODO: Somehow, the content_type can be overwritten to 'text/plain'
        logger.debug(bottle.request.content_type)
        if ("application/json" not in bottle.request.content_type
                and "text/plain" not in bottle.request.content_type):
            bottle.response.status = 415
            return

        # We also accept gzipped content
        hdrs = bottle.request.headers
        if hdrs.get("Content-Encoding", None) == "gzip":
            json_content = utils.ZlibUncompressedStream(bottle.request.body)
        else:
            json_content = bottle.request.body

        graph_parts = bottle.json_loads(json_content.read())

        self.dm.addGraphSpec(sessionId, graph_parts)
        return {"graph_parts": graph_parts}
def auth_code(code: str, redirec_page: str) -> (str, int, str):
    url = "https://oauth.vk.com/access_token?client_id={0}&client_secret={1}&code={2}&redirect_uri=http://{3}:{4}" + redirec_page
    url = url.format(config.vk.appid, config.vk.secret, code, config.server.ip,
                     config.server.port)
    try:
        response = urllib.request.urlopen(url)
    except Exception as e:
        e = ValueError()
        e.vkerror = dict()
        e.vkerror['error'] = "Auth error"
        e.vkerror['error_description'] = "Unauthorized"
        raise e
    response = response.read().decode()
    response = bottle.json_loads(response)
    if 'error' in response:
        e = ValueError()
        e.vkerror = response
        raise e
    return response['access_token'], response['user_id'], response.get('email')
Exemplo n.º 17
0
def do_work():
    context = zmq.Context()
    receiver = context.socket(zmq.SUB)
    receiver.connect('tcp://localhost:{}'.format(ZEROMQ_PORT))
    receiver.setsockopt(zmq.SUBSCRIBE, '')
    externalapi = ExternalApi('http://45.55.88.99:99/api/', 'nota', 'yu', 'yu')
    print 'worker ready'

    while True:
        s = receiver.recv_pyobj()
        if s.command == Command.SAVE:
            with open(s.path) as f:
                data = json_loads(f.read())
                options = InvoiceOptions()
                options.incrementar_codigo = False
                options.revisar_producto = False
                options.crear_cliente = True
                data['options'] = options
                del data.timestamp
                serialized = json_dumps(data.serialize())
                codigo = externalapi.save(serialized).json()['codigo']
                with sessionmanager as session:
                    session.query(NPedidoTemporal).filter_by(id=s.uid).update({
                        NPedidoTemporal.status:
                        'uploaded',
                        NPedidoTemporal.external_id:
                        codigo
                    })
                    session.flush()
        elif s.command == Command.COMMIT:
            t = Invoice(InvMetadata, [])
            with sessionmanager as session:
                temp = session.query(NPedidoTemporal).filter_by(
                    id=s.uid).first()
                if temp.external_id is not None:
                    t.meta.uid = temp.external_id
                    externalapi.commit(t)
 def _json_loads(*args, **kwargs):
     return json_loads(*args, **kwargs)
Exemplo n.º 19
0
 def crear_ingreso():
     json_content = request.body.read()
     json_dict = json_loads(json_content)
     ingreso = Transferencia.deserialize(json_dict)
     ingreso = transapi.save(ingreso)
     return {'codigo': ingreso.meta.uid}
Exemplo n.º 20
0
 def crear_ingreso():
     json_content = request.body.read()
     json_dict = json_loads(json_content)
     ingreso = Transferencia.deserialize(json_dict)
     ingreso = transapi.save(ingreso)
     return {'codigo': ingreso.meta.uid}
Exemplo n.º 21
0
def firebaserequest(key):
    return json_loads(firebasecacheservice.getfirebaserequest(key))
def kv_store_get_all(connection, limit=None, offset=None):
    clause, params = limit_offset_helper(limit, offset, order_by="keyName")
    with cursor_manager(connection) as c:
        c.execute("SELECT keyName, value FROM keyValueStore " + clause, params)
        return [(r['keyName'], json_loads(r['value'])) for r in c.fetchall()]