Example #1
0
def buy_drink(drink, payment, name):
    span = trace.newspan(tracer, None, 'transaction')
    span.set_tag('drink', drink)
    span.set_tag('customer', name)
    span.set_tag('payment', payment)

    res = trace.inject_in_header(tracer, span, {})

    span.finish()

    if True:
        print(name + ' buys ' + drink)
        API.call_api(data_server, data_port, '/wip/add/' + drink, res)
        API.call_api(data_server, data_port, '/add/client', res)
        r = API.call_api(produce_server, produce_port, '/produce/' + drink,
                         res)

        if r.status_code == 200:
            r = API.call_api(bill_server, bill_port,
                             '/bill/' + payment + '/' + name, res)
            if r.status_code == 200:
                span.set_tag('error', False)
            else:
                span.set_tag('error', True)
                span.set_tag('bill', r.status_code)
        else:
            span.set_tag('error', True)
        response = app.response_class(response=json.dumps(res),
                                      status=r.status_code,
                                      mimetype='application/json')
        API.call_api(data_server, data_port, '/wip/sup/' + drink, res)
        return response
def produce_drink(drink):
    print('produce '+drink)

    response = app.response_class(
        status=404,
        mimetype='application/json'
    )

    span = trace.newspan(
        tracer,
        trace.getparentspanfromheader(tracer, request),
        drink
    )
    res = trace.inject_in_header(tracer, span, {})

    result = API.call_api(data_server, data_port, '/state', res)
    decoded = result.content.decode()
    _state = json.loads(decoded)

    error = False
    if True:
        if _state['water'] <= 0:
            API.call_api(data_server, data_port, '/resource/add/water', res)
        else:
            if drink == 'coffee' and _state['coffee_bean'] <= 0:
                API.call_api(data_server, data_port, '/resource/add/' + drink, res)
                error = True
                span.set_tag('reason', 'need ' + drink)
            elif drink == 'tea' and _state['tea_leaf'] <= 0:
                API.call_api(data_server, data_port, '/resource/add/' + drink, res)
                error = True
                span.set_tag('reason', 'need '+drink)
            else:
                r = API.call_api(data_server, data_port, '/consume/water', res)
                if r.status_code == 200:
                    API.call_api(data_server, data_port, '/consume/'+drink, res)
                    time.sleep(random.randint(0, 500) / 1000)

                    response = app.response_class(
                        status=200,
                        mimetype='application/json'
                    )
                    print(drink + ' produced')

        # span.status = status.Status( response.status,'TODO')

        span.set_tag('error', error)
        span.finish()
        return response
Example #3
0
def range_split(z3inst, module, num_split, order="biggest"):
    initial_num_split = num_split
    #only consider ranges of top level abstracts that are referring to the same type of concretes
    pairs = []
    for i in z3inst.cfr_sorts.values():
        glCardRange = i.numInstances - i.element.glCard[0].value + 1
        if glCardRange > 1:
            pairs.append((i, glCardRange))
    if order == "random":
        random.shuffle(pairs)
    else:
        pairs.sort(key=operator.itemgetter(1))
        if order == "biggest":
            pairs.reverse()
    constraints = []

    splitters = []
    curr_count = 0
    for i in pairs:
        (claferSort, card_range) = i
        splitters.append(claferSort)
        curr_count = curr_count + card_range
        if curr_count >= num_split:
            break
    if curr_count < num_split:
        return safe_raise_heuristic_failure_exception(order + "_range_split" +
                                                      str(initial_num_split) +
                                                      " failed.")
    else:
        ranges = []
        for i in splitters:
            curr_range = []
            for j in range(i.element.glCard[0].value, i.numInstances + 1):
                left = API.createCard(API.createArg(i.element.uid, i))
                right = API.createInteger(j)
                bc = CreateBracketedConstraints.CreateBracketedConstraints(
                    z3inst, True)
                constraint = bc.generatedConstraintVisit(
                    API.createEquals(left, right))
                curr_range.append(constraint)
            ranges.append(curr_range)
        products = list(itertools.product(*ranges))
        products = [[And(*list(i))] for i in products]
        products = condense(products, num_split)
        return products

    return safe_raise_heuristic_failure_exception(order + "_range_split" +
                                                  str(initial_num_split) +
                                                  " failed.")
Example #4
0
def range_split(z3inst, module, num_split, order="biggest"):
    initial_num_split = num_split
    #only consider ranges of top level abstracts that are referring to the same type of concretes
    pairs = []
    for i in z3inst.cfr_sorts.values():
        glCardRange = i.numInstances - i.element.glCard[0].value + 1
        if glCardRange > 1:
            pairs.append((i, glCardRange))
    if order == "random":
        random.shuffle(pairs)
    else:
        pairs.sort(key=operator.itemgetter(1))
        if order == "biggest":
            pairs.reverse()
    constraints = []
    
    splitters = []
    curr_count = 0
    for i in pairs:
        (claferSort, card_range) = i
        splitters.append(claferSort)
        curr_count = curr_count + card_range
        if curr_count >= num_split:
            break
    if curr_count < num_split:
        return safe_raise_heuristic_failure_exception(order + "_range_split" + str(initial_num_split) + " failed." )
    else:
        ranges = []
        for i in splitters:
            curr_range = []
            for j in range(i.element.glCard[0].value, i.numInstances + 1):
                left = API.createCard(API.createArg(i.element.uid, i))
                right = API.createInteger(j)
                bc = CreateBracketedConstraints.CreateBracketedConstraints(z3inst, True)
                constraint = bc.generatedConstraintVisit(API.createEquals(left, right))
                curr_range.append(constraint)
            ranges.append(curr_range)
        products = list(itertools.product(*ranges))
        products = [[And(*list(i))] for i in products]
        products = condense(products, num_split)
        return products
    
    return safe_raise_heuristic_failure_exception(order + "_range_split" + str(initial_num_split) + " failed." )
Example #5
0
def consume(r):
    global tea_leaf, coffee_bean, water
    s = 200
    print('consume ' + r)
    span = trace.newspan(tracer,
                         trace.getparentspanfromheader(tracer, request),
                         'consume ' + r)
    res = trace.inject_in_header(tracer, span, {})

    error = False
    if resources[r] <= 0:
        API.call_api(
            data_server,
            data_port,
            '/resource/add/' + r,
            res,
        )
        s = 404
        error = True
    else:
        resources[r] += -1
        json_body = [{
            "measurement": "rt",
            "tags": {
                "type": r
            },
            "fields": {
                "resource": resources[r],
                "movement": -1
            }
        }]
        client_influx.write_points(json_body)

        time.sleep(random.randint(0, 50) / 1000)
        print(r + ' ' + str(resources[r]))

    span.set_tag('error', error)
    res = {}
    response = app.response_class(response=json.dumps(res),
                                  status=s,
                                  mimetype='application/json')
    span.finish()
    return response
Example #6
0
def divide_biggest_ranges_in_two(z3inst, module, num_split):
    initial_num_split = num_split
    pairs = []
    for i in z3inst.cfr_sorts.values():
        glCardRange = i.numInstances - i.element.glCard[0].value + 1
        if glCardRange > 1:
            pairs.append((i, glCardRange))
        pairs.append((i, glCardRange))
    pairs.reverse()
    constraints = [True]
    try:
        while num_split != 1:
            num_split = num_split // 2
            (currSort, currRange) = pairs.pop(0)

            left1 = API.createCard(
                API.createArg(currSort.element.uid, currSort))
            right1 = API.createInteger(currSort.element.glCard[0].value +
                                       (currRange // 2))
            bc1 = CreateBracketedConstraints.CreateBracketedConstraints(
                z3inst, True)
            constraint1 = bc1.generatedConstraintVisit(
                API.createLT(left1, right1))

            left2 = API.createCard(
                API.createArg(currSort.element.uid, currSort))
            right2 = API.createInteger(currSort.element.glCard[0].value +
                                       (currRange // 2))
            bc2 = CreateBracketedConstraints.CreateBracketedConstraints(
                z3inst, True)
            constraint2 = bc2.generatedConstraintVisit(
                API.createLE(right2, left2))

            newConstraints = []
            for i in constraints:
                newConstraints.append(mAnd(i, constraint1))
            for i in constraints:
                newConstraints.append(mAnd(i, constraint2))
            constraints = newConstraints
    except:
        return safe_raise_heuristic_failure_exception(
            "divide_biggest_ranges_in_two#" + str(initial_num_split) +
            "failed.")
    if num_split != 1:
        return safe_raise_heuristic_failure_exception(
            "divide_biggest_ranges_in_two#" + str(initial_num_split) +
            "failed.")
    return constraints

    sys.exit(
        "INCOMPLETE: need to figure out what to do when run out of splits")
Example #7
0
    def drink(self):
        r = random.getrandbits(1)
        p = means_of_payment[random.getrandbits(1)]
        try:
            res = API.call_api(buy_server, buy_port, '/buy/'+drinks[r]+'/' + p + '/' + self.name, {})
            print('/buy/'+drinks[r]+'/' + p + '/' + self.name+' > '+str(res))
            self.energy = energy.get(drinks[r])

            self.last = True
        except Exception as e:
            print(e)
            self.last = False
Example #8
0
def divide_biggest_ranges_in_two(z3inst, module, num_split):
    initial_num_split = num_split
    pairs = []
    for i in z3inst.cfr_sorts.values():
        glCardRange = i.numInstances - i.element.glCard[0].value + 1
        if glCardRange > 1:
            pairs.append((i, glCardRange))
        pairs.append((i, glCardRange))
    pairs.reverse()
    constraints = [True]
    try:
        while num_split != 1:
            num_split = num_split // 2
            (currSort,currRange) = pairs.pop(0)
            
            left1 = API.createCard(API.createArg(currSort.element.uid, currSort))
            right1 = API.createInteger(currSort.element.glCard[0].value + (currRange//2))
            bc1 = CreateBracketedConstraints.CreateBracketedConstraints(z3inst, True)
            constraint1 = bc1.generatedConstraintVisit(API.createLT(left1, right1))
            
            left2 = API.createCard(API.createArg(currSort.element.uid, currSort))
            right2 = API.createInteger(currSort.element.glCard[0].value + (currRange//2))
            bc2 = CreateBracketedConstraints.CreateBracketedConstraints(z3inst, True)
            constraint2 = bc2.generatedConstraintVisit(API.createLE(right2, left2))
            
            newConstraints = []
            for i in constraints:
                newConstraints.append(mAnd(i, constraint1))
            for i in constraints:
                newConstraints.append(mAnd(i, constraint2))
            constraints = newConstraints
    except:
        return safe_raise_heuristic_failure_exception("divide_biggest_ranges_in_two#" + str(initial_num_split) + "failed.") 
    if num_split != 1:
        return safe_raise_heuristic_failure_exception("divide_biggest_ranges_in_two#" + str(initial_num_split) + "failed.") 
    return constraints
    
    
    sys.exit("INCOMPLETE: need to figure out what to do when run out of splits")
Example #9
0
def bill(payment, name):
    span = trace.newspan(tracer,
                         trace.getparentspanfromheader(tracer,
                                                       request), 'bill')
    span.set_tag('customer', name)
    span.set_tag('payment', payment)

    res = trace.inject_in_header(tracer, span, {})

    res = API.call_api(data_server, data_port, '/cashin/' + payment, res)
    span.finish()
    sspan = trace.newspan(tracer, span.context, payment)

    time.sleep(random.randint(0, 200) / 1000)

    response = app.response_class(response=json.dumps({}),
                                  status=200,
                                  mimetype='application/json')

    sspan.finish()
    return response
Example #10
0
# CORS(app)
i = 0
while True:
    if i == 0:
        root = trace.newspan(tracer, None, 'root')
    i += 1
    if i == 10:
        root.finish()
        i = 0
    r = None
    try:
        # span = trace.newspan(tracer, root.context, 'pushdata')
        span = trace.newspan(tracer, None, 'pushdata')
        sspan = trace.newspan(tracer, span.context, 'ask data')
        res = trace.inject_in_header(tracer, span, {})
        r = API.call_api(data_server, data_port, '/state', res)
        # print(r.content)
        j = json.loads(r.content.decode())
        sspan.finish()
        sspan = trace.newspan(tracer, sspan.context, 'push tea')
        json_body = [{
            "measurement": "coffeetea",
            "tags": {
                "type": "tea",
                "fill": j['fill_tea_in_progress'],
            },
            "fields": {
                "resource": j['tea_leaf'],
                "refills": 1.0 if j['fill_tea_in_progress'] else 0.0,
                "wip_produce": j['tea_in_progress'],
            }
import p2api
import pytest
import requests

from common import API


api = API()
api.connect()


def test_cannot_delete_finding_chart_if_not_authenticated():
    response = requests.delete(f'{api.API_URL}/obsBlocks/0/findingCharts/0')
    assert response.status_code == 401


def test_cannot_delete_finding_chart_of_invalid_observing_block():
    ob_id = 'invalid'  # invalid observing block ID
    index = 1

    response = api.make_request(
        'DELETE', f'/obsBlocks/{ob_id}/findingCharts/{index}')

    assert response.status_code == 400


@pytest.mark.parametrize('invalid_index', [('invalid',), (0,), (6,)])
def test_cannot_delete_invalid_finding_chart(invalid_index):
    ob_id = api.create_observing_block();

    response = api.make_request(
Example #12
0
  # match_id = "1deb2118-557e-4945-a8e1-81ae70bf62e3"
  # match_id = "42f94823-1e69-423e-983a-02f0973c9534"  # duo/sanhok
  # match_id = "1859feb8-e65e-46eb-9ef0-555082002695"  # squad/sanhok
  # match_id = "e15b4139-38f8-4e67-a6ae-2f0c7cb02881"  # erangel/squad lame
  # match_id = "64c6a84d-49b4-4c6c-943e-26bc8676b611"
  match_id = "9ff7d88c-0665-438a-9e73-c562c7eb0a46"
  
  ds = dataset.Dataset(match_id)

  # print(ds.get_team('eponymoose'))
  # plot_location_overlay(ds, ds.get_team('eponymoose'))
  # plot_distance_from_zone(ds)
  # plot_distance_from_zone_player_highlighted(ds, 'eponymoose')
  # plot_distance_from_zone_player_comparison(ds, 'eponymoose')
  # plot_distance_from_zone_player_comparison(ds)

  api = API()

  for i, (player, match) in enumerate(api.iter_player_matches('eponymoose')):
    ds = dataset.Dataset(match.id)

    try:
      plot_distance_from_zone_player_comparison(ds, 'eponymoose')

    except IndexError:
      print("INDEX ERROR! {}".format(i))
      continue
    
    except TypeError:
      print("TYPE ERROR! {}".format(i))
      continue