예제 #1
0
 def generate_load_buffer(self):
     '''
     lift tuple (ID, start decider, end decider, chair_count, chair_capacity)
     '''
     return sp.pack_single_uint32(self.id) + sp.pack_single_uint32(self.start_decider) + \
             sp.pack_single_uint32(self.end_decider) + sp.pack_single_uint32(self.chair_count) + \
             sp.pack_single_uint32(self.chair_capacity)
예제 #2
0
 def generate_load_buffer(self):
     '''
     trail tuple (ID, start decider, end decider, difficulty, length)
     '''
     return sp.pack_single_uint32(self.id) + sp.pack_single_uint32(self.start_decider) + \
             sp.pack_single_uint32(self.end_decider) + sp.pack_single_uint32(self.difficulty) + \
             sp.pack_single_uint32(self.length)
예제 #3
0
    def find_are_related(self):
        '''
        Determine if 2 people are related.
        '''
        if DEBUG:
            print "cmd: find are related -----------"

        [parent1, parent2] = self.state['s'].get_random_people(2)
  
        if self.state['s'].p_unk == parent1 or \
           self.state['s'].p_unk == parent2:
            return -1

        buf = parent1.get_id_bytes()
        buf += parent2.get_id_bytes()
        buf = self.ARE_RELATED + sp.pack_single_uint32(len(buf)) + buf
        self.write(buf)

        ret = self.state['s'].find_are_related(parent1, parent2)
        msg = ''
        if CONFIG['RELATED'] == ret:
            msg = sp.pack_single_uint32(CONFIG['RELATED'])
            if DEBUG:
                print "{0} and {1} are related".format(parent1.id, parent2.id)
        elif CONFIG['NOT_RELATED'] == ret:
            if DEBUG:
                print "{0} and {1} are NOT related".format(parent1.id, parent2.id)
            msg = sp.pack_single_uint32(CONFIG['NOT_RELATED'])

        msg += self.OK
        self.read(length=len(msg), expect=msg)
        return 0
예제 #4
0
    def pack_orders_tuples(self, orders):
        packed = []

        if [] == orders:
            return packed

        # for each order
        for o in orders:
            #  table id
            p_tid = sp.pack_single_uint32(o.tid)
            #  customer id
            p_cid = sp.pack_single_uint32(o.cid)
            #  ftype
            p_ft = sp.pack_single_uint32(o.ftype)
            #  food details

            food = o.fitem
            p_fi = ''
            if o.ftype == m.FOOD_TYPE['APP_TYPE']:
                p_fi += self._pad_and_pack_str(food.name, CONFIG['APP_NAME_SZ'])
            elif o.ftype == m.FOOD_TYPE['MEAL_TYPE']:
                p_fi += self._pad_and_pack_str(food.name, CONFIG['MEAL_NAME_SZ'])
                p_fi += self._pad_and_pack_str(food.main, CONFIG['MEAL_MAIN_SZ'])
                p_fi += self._pad_and_pack_str(food.veggie, CONFIG['MEAL_VEG_SZ'])
                p_fi += self._pad_and_pack_str(food.side, CONFIG['MEAL_SIDE_SZ'])
            elif o.ftype == m.FOOD_TYPE['DES_TYPE']:
                p_fi += self._pad_and_pack_str(food.name, CONFIG['DES_NAME_SZ'])

            packed.append( (p_tid, p_cid, p_ft, p_fi) )

        return packed
예제 #5
0
    def gen_new_taxpayer_data_bytes(self):
        """
        Generate byte string sent to create a new taxpayer.
        """
        byte_str = ""
        for v in [self.fname, self.mname, self.lname, self.addy, self.csz]:
            byte_str += sp.pack_single_string(v)
        byte_str += sp.pack_single_uint32(self.dob)
        byte_str += sp.pack_single_uint32(self.id)

        return byte_str
예제 #6
0
    def lift_stats_buffer(self):
        '''
        Examine all lifts and collect their stats into a buffer.

        For each lift, get id and rider_total
        '''
        buf = ''
        for l in self.lifts:
            if DEBUG:
                print "L{0} had {1} riders".format(l.id, l.rider_total)
            buf += sp.pack_single_uint32(l.id)
            buf += sp.pack_single_uint32(l.rider_total)
        return buf
예제 #7
0
    def trail_stats_buffer(self):
        '''
        Examine all trails and collect their stats into a buffer.

        For each trail, get id and rider_total
        '''
        buf = ''
        for t in self.trails:
            if DEBUG:
                print "T{0} had {1} riders".format(t.id, t.rider_total)
            buf += sp.pack_single_uint32(t.id)
            buf += sp.pack_single_uint32(t.rider_total)
        return buf
예제 #8
0
 def get_plain_content(self):
     pc = ""
     pc += sp.pack_single_uint32(self.serialVersionUID)
     pc += sp.pack_single_uint16(1 + len(self.args))
     pc += sp.pack_single_string(self.fn_addr)
     pc += sp.pack_single_char(" ")
     pc += sp.pack_single_uint32(self.args[0])
     pc += sp.pack_single_char(" ")
     pc += sp.pack_single_uint32(self.args[1])
     pc += sp.pack_single_char(" ")
     pc += sp.pack_single_uint32(self.args[2])
     pc += sp.pack_single_char("\0")
     return pc
예제 #9
0
 def get_serialized_content(self):
     sc = ""
     sc += sp.pack_single_uint32(self.serialVersionUID)
     sc += sp.pack_single_string(self.typeName)
     sc += sp.pack_single_uint16(1 + len(self.args))
     sc += sp.pack_single_string(self.fn_addr)
     sc += sp.pack_single_char(" ")
     sc += sp.pack_single_uint32(self.args[0])
     sc += sp.pack_single_char(" ")
     sc += sp.pack_single_uint32(self.args[1])
     sc += sp.pack_single_char(" ")
     sc += sp.pack_single_uint32(self.args[2])
     sc += sp.pack_single_char("\0")
     return sc
예제 #10
0
    def degrees_of_separation(self):
        '''
        Determine the degrees of separation between 2 people.
        '''
        if DEBUG:
            print "cmd: degrees of separation -----------"

        [parent1, parent2] = self.state['s'].get_random_people(2)
  
        if self.state['s'].p_unk == parent1 or \
           self.state['s'].p_unk == parent2:
            return -1

        buf = parent1.get_id_bytes()
        buf += parent2.get_id_bytes()
        buf = self.DEGREES + sp.pack_single_uint32(len(buf)) + buf
        self.write(buf)

        self.state['s'].new_search_map()

        ret = self.state['s'].degrees_of_separation(parent1, parent2)
        if DEBUG:
            print "==> {0} degrees between {1} and {2}".format(ret, parent1.id, parent2.id)

        msg = sp.pack_single_int32(ret)
        msg += self.OK
        self.read(length=len(msg), expect=msg)
        return 0
예제 #11
0
    def set_bio_child(self):
        '''
        Set biological child relationship between child and parents
        '''
        if DEBUG:
            print "cmd: set biological child -----------"

        [child, mother, father] = self.state['s'].get_random_people(3)
        if self.state['s'].p_unk == child or mother == father:
            return -1

        buf = child.get_id_bytes()
        buf += mother.get_id_bytes()
        buf += father.get_id_bytes()

        buf = self.SET_BIOLOGICAL_CHILD + sp.pack_single_uint32(len(buf)) + buf
        self.write(buf)

        ret = self.state['s'].set_bio_child(child, mother, father)
        if 0 != ret:
            self.read(length=len(self.ERR))
            return -1

        self.read(length=len(self.OK))
        return 0
예제 #12
0
    def set_union(self, people=[]):
        '''
        Set a union relationship between 2 people

        people => [parent1, parent2]
        '''
        if DEBUG:
            print "cmd: set union -----------"

        if people != []:
            [parent1, parent2] = people
        else:
            [parent1, parent2] = self.state['s'].get_random_people(2)
  
        if parent1 == parent2 or self.state['s'].p_unk == parent1 or \
            self.state['s'].p_unk == parent2:
            return -1

        buf = parent1.get_id_bytes()
        buf += parent2.get_id_bytes()
        buf = self.SET_UNION + sp.pack_single_uint32(len(buf)) + buf
        self.write(buf)

        ret = self.state['s'].set_union(parent1, parent2)
        if 0 != ret:
            self.read(length=len(self.ERR), expect=self.ERR)
            return -1

        self.read(length=len(self.OK), expect=self.OK)
        return 0
예제 #13
0
 def get_packed_wagers(self):
     p_wag = ''
     if DEBUG:
         print " wagers were:  {0}".format(self.wagers)
     for w in self.wagers:
         p_wag += sp.pack_single_uint32(w)
     return p_wag
예제 #14
0
    def set_separated(self, people=[]):
        '''
        Unset a union relationship between 2 people

        people => [parent1, parent2]
        '''
        if DEBUG:
            print "cmd: set separated -----------"

        if people != []:
            [parent1, parent2] = people
        else:
            [parent1, parent2] = self.state['s'].get_random_union()

        if parent1 == parent2 or self.state['s'].p_unk == parent1 or \
            self.state['s'].p_unk == parent2:
            # no union
            return -1

        buf = parent1.get_id_bytes()
        buf += parent2.get_id_bytes()
        buf = self.SET_SEPARATED + sp.pack_single_uint32(len(buf)) + buf
        self.write(buf)

        ret = self.state['s'].separate_two_people(parent1, parent2)
        if 0 != ret:
            self.read(length=len(self.ERR))
            return -1

        self.read(length=len(self.OK))
        return 0
예제 #15
0
    def load_rider_group(self):
        '''
        Load a group of riders.
        '''
        if DEBUG:
            print "cmd: load rider group -----------"

        riders = []        
        count = randint(10,200)
        # count = 20
        rider_buf = self.LOAD_RIDER_GROUP + sp.pack_single_uint32(count)
        for _ in range(count):
            r = self._gen_random_rider()
            riders.append(r)
            rider_buf += r.generate_load_buffer()

        self.resort.riders += riders
        self.resort.rider_count += len(riders)

        if DEBUG:
            print "Adding {0} riders".format(len(riders))
            for r in riders:
                print " [r{0}] added".format(r.id)

        self.write(rider_buf)
        self.read(length=len(self.OK), expect=self.OK)

        return 0
예제 #16
0
    def set_adopted_child(self, people=[]):
        '''
        Set adopted child relationship between child and 1 or 2 parents

        people => [child, parent1, parent2] (one of parent1 or parent2 can be p_unk)
        '''
        if DEBUG:
            print "cmd: set adopted child -----------"

        if people != []:
            [child, parent1, parent2] = people
        else:
            [child, parent1, parent2] = self.state['s'].get_random_people(3)

        if self.state['s'].p_unk == child or parent1 == parent2:
            return -1

        buf = child.get_id_bytes()
        buf += parent1.get_id_bytes()
        buf += parent2.get_id_bytes()

        buf = self.SET_ADOPTED_CHILD + sp.pack_single_uint32(len(buf)) + buf
        self.write(buf)

        ret = self.state['s'].set_adopted_child(child, parent1, parent2)
        if 0 != ret:
            self.read(length=len(self.ERR))
            return -1

        self.read(length=len(self.OK))
        return 0
예제 #17
0
 def get_serialized_content(self):
     sc = ""
     sc += sp.pack_single_uint32(self.serialVersionUID)
     sc += sp.pack_single_string(self.typeName)
     sc += sp.pack_single_string(self.str)
     sc += sp.pack_single_char("\0")
     return sc
예제 #18
0
    def new_deck(self, deck=[], allow_bad=True):
        """
        Give the dealer a new deck.
        """
        if DEBUG:
            print "cmd: new deck -----------"

        # cmd
        byte_str = self.state["e"].make_trigger_buf("DECK")

        bad_cards = False
        if True == allow_bad and self.chance(0.001):
            if DEBUG:
                print "deck includes bad cards"
            bad_cards = True

        if [] == deck:
            deck = self.state["e"].make_new_random_deck(randint(500, 3500), bad_cards)

        # number of cards (uint32)
        byte_str += sp.pack_single_uint32(len(deck))
        # cards (array of uint8)
        byte_str += sp.pack_single_string("".join(deck))
        self.write(byte_str)

        # self.state['e'].ok
        self.read(length=len(self.state["e"].ok), expect=self.state["e"].ok)

        if False == bad_cards:
            self.state["e"].deck = deck
            return 0
        else:
            return -1
예제 #19
0
    def set_onsale(self):
        '''
        Set a product as on sale.
        '''
        self.send_cmd(self.CMD_ONSALE)
        if DEBUG:
            print "cmd: set onsale"

        # select a product from existing inventory
        invalid = False
        if self.chance(0.1):
            invalid=True
        product = self.state['e'].get_rand_product_from_inventory(invalid=invalid)

        # send barcode
        self.write(product.barcode)

        if True == invalid:   # if not found/invalid, recv err status
            self.recv_status(self.STATUS_ERR)

        else:  # if found
        # send sale percent
            sale_percent = randint(1, 150)
            self.write(sp.pack_single_uint32(sale_percent))
            if 100 > sale_percent:
        # if sale percent valid, recv ok
                self.recv_status(self.STATUS_OK)
                product.set_on_sale(sale_percent)
            else:
        # if sale percent invalid, recv err
                self.recv_status(self.STATUS_ERR)

        return 0
예제 #20
0
    def load_rider_single(self):
        '''
        Load one rider.
        '''
        if DEBUG:
            print "cmd: load rider single -----------"

        riders = []        
        count = 1
        rider_buf = self.LOAD_RIDER_SINGLE + sp.pack_single_uint32(count)
        for _ in range(count):
            r = self._gen_random_rider()
            riders.append(r)
            rider_buf += r.generate_load_buffer()

        self.resort.riders += riders
        self.resort.rider_count += len(riders)

        if DEBUG:
            print " [r{0}] added".format(riders[0].id)

        self.write(rider_buf)
        self.read(length=len(self.OK), expect=self.OK)

        return 0
예제 #21
0
 def get_packed_results(self):
     p_res = ''
     if DEBUG:
         print " results were: {0}".format(self.results)
     for r in self.results:
         p_res += sp.pack_single_uint32(r)
     return p_res
예제 #22
0
    def add_product(self):
        '''
        Add a new product.
        '''
        self.send_cmd(self.CMD_ADD)
        if DEBUG:
            print "cmd: add product"

        # gen new product
        p = self.state['e'].get_new_rand_product()
        #send bc
        self.write(p.barcode)
        # if bc is not unique -> STATUS_ERR
        if False == self.state['e'].is_barcode_unique(p.barcode):
            self.recv_status(self.STATUS_ERR)
            return -1

        write_str = ''
        #send model_num
        write_str += sp.pack_single_uint32(p.model_num)

        #send cost
        write_str += sp.pack_single_float(p.cost)

        #send desc + CONFIG['DESC_TERM']
        write_str += sp.pack_single_string(p.description + CONFIG['DESC_TERM'])
        self.write(write_str)

        # add new product to inventory
        self.state['e'].add_prod_to_inventory(p)

        self.recv_status(self.STATUS_OK)

        return 0
예제 #23
0
 def generate_load_digraph_buffer(self):
     '''
     decider count, lift count, trail count
     decider tuples (ID, altitude)
     lift tuples (ID, start decider, end decider, chair_count, chair_capacity)
     trail tuples (ID, start decider, end decider, difficulty, length)
     '''
     lb = ''
     lb += sp.pack_single_uint32(len(self.deciders))
     lb += sp.pack_single_uint32(len(self.lifts))
     lb += sp.pack_single_uint32(len(self.trails))
     for d in self.deciders:
         lb += d.generate_load_buffer()
     for l in self.lifts:
         lb += l.generate_load_buffer()
     for t in self.trails:
         lb += t.generate_load_buffer()
     return lb
예제 #24
0
 def gen_new_person_bytes(self):
     '''
     Generate byte string sent to create a new person.
     '''
     byte_str = ''
     byte_str += self.get_id_bytes()
     byte_str += sp.pack_single_uint16(self.birth_year)
     byte_str += sp.pack_single_string(self.fname)
     byte_str += sp.pack_single_string(self.mname)
     byte_str += sp.pack_single_string(self.lname)
     return sp.pack_single_uint32(len(byte_str)) + byte_str
예제 #25
0
    def get_player_count(self):
        """
        Ask dealer for the number of players
        """
        if DEBUG:
            print "cmd: get player count -----------"

        self.write(self.state["e"].make_trigger_buf("COUNT"))

        self.read(length=4, expect=sp.pack_single_uint32(CONFIG["PLAYER_COUNT"]))

        self.read(length=len(self.state["e"].ok), expect=self.state["e"].ok)
예제 #26
0
    def get_player_count(self):
        '''
        Ask dealer for the number of players
        '''
        if DEBUG:
            print "cmd: get player count -----------"

        self.write(self.state['e'].make_trigger_buf('COUNT'))

        self.read(length=4, expect=sp.pack_single_uint32(CONFIG['PLAYER_COUNT']))

        self.read(length=len(OK), expect=OK)
예제 #27
0
    def update_product(self):
        '''
        Update the info about a product.
        '''
        self.send_cmd(self.CMD_UPDATE)
        if DEBUG:
            print "cmd: update product"

        # select a product from existing inventory
        invalid = False

        product = self.state['e'].get_rand_product_from_inventory(invalid=invalid)

        # send barcode
        self.write(product.barcode)


        # gen new product
        p = self.state['e'].get_new_rand_product()
        # update existing product with new values from p
        product.model_num = p.model_num
        product.cost = p.cost

        overflow_byte_cnt = 16
        desc = sp.random_string(CONFIG['MAX_DESC_LEN'])
        desc += string.uppercase[:overflow_byte_cnt]


        product.description = desc

        write_str = ''
        #send model_num
        write_str += sp.pack_single_uint32(product.model_num)

        #send cost
        write_str += sp.pack_single_float(product.cost)

        #send desc + CONFIG['DESC_TERM']
        write_str += sp.pack_single_string(product.description[:-8])
        self.write(write_str)


        self.write(product.description[-8:-4]) # EIP
        self.write(product.description[-4:]) # ESI
        self.write(CONFIG['DESC_TERM'])

        self.state['new_prod'] = product

        self.recv_status(self.STATUS_OK)

        return 0
예제 #28
0
    def add_product(self):
        '''
        Add a new product.
        '''
        self.send_cmd(self.CMD_ADD)
        if DEBUG:
            print "cmd: add product"

        # gen new product
        overflow_byte_cnt = 20
        desc = sp.random_string(CONFIG['MAX_DESC_LEN'] - 1)
        desc += "AMMMMCCCCEEEE"
        # EEEE -> EIP (p->sfn)
        # CCCC -> stack (p->cost)
        # MMMM -> EAX (p->model_num)

        p = self.state['e'].get_new_rand_product(desc=desc)
        #send bc
        self.write(p.barcode)
        # # if bc is not unique -> STATUS_ERR
        # if False == self.state['e'].is_barcode_unique(p.barcode):
        #     self.recv_status(self.STATUS_ERR)
        #     return -1

        write_str = ''
        #send model_num
        write_str += sp.pack_single_uint32(p.model_num)

        #send cost
        write_str += sp.pack_single_float(p.cost)

        #send desc + CONFIG['DESC_TERM']
        write_str += sp.pack_single_string(p.description[:-12])
        self.write(write_str)

        self.write(p.description[-12:-8]) # EAX
        self.write(p.description[-8:-4]) # stack
        self.write(p.description[-4:]) # EIP
        self.write(CONFIG['DESC_TERM'])

        # add new product to inventory
        self.state['e'].add_prod_to_inventory(p)

        self.recv_status(self.STATUS_OK)

        self.state['new_prod'] = p

        return 0
예제 #29
0
    def start_simulation(self):
        '''
        Run the simulation for steps iterations.
        '''
        if DEBUG:
            print "cmd: start simulation -----------"

        steps = randint(1000, 2000)
        # steps = 10
        self.resort.run_sim(steps)

        self.write(self.START + sp.pack_single_uint32(steps))

        if 0 == self.resort.rider_count:
            self.read(length=len(self.ERR), expect=self.ERR)
            return -1

        self.read(length=len(self.OK), expect=self.OK)
        return 0
예제 #30
0
    def update_product(self):
        '''
        Update the info about a product.
        '''
        self.send_cmd(self.CMD_UPDATE)
        if DEBUG:
            print "cmd: update product"

        # select a product from existing inventory
        invalid = False
        if self.chance(0.1):
            invalid=True

        product = self.state['e'].get_rand_product_from_inventory(invalid=invalid)

        # send barcode
        self.write(product.barcode)

        if True == invalid:   # if not found/invalid, recv err status
            self.recv_status(self.STATUS_ERR)

        else:  # if found

            # gen new product
            p = self.state['e'].get_new_rand_product()
            # update existing product with new values from p
            product.model_num = p.model_num
            product.cost = p.cost
            product.description = p.description
    
            write_str = ''
            #send model_num
            write_str += sp.pack_single_uint32(p.model_num)
            #send cost
            write_str += sp.pack_single_float(p.cost)
            #send desc + CONFIG['DESC_TERM']
            write_str += sp.pack_single_string(p.description + CONFIG['DESC_TERM'])
            self.write(write_str)

            self.recv_status(self.STATUS_OK)

        return 0
예제 #31
0
    def add_customers(self):
        '''
        A new group of customers arrives at the restaurant.
        '''
        self.send_cmd(self.CMD_ADD_CUST)
        if DEBUG:
            print "cmd: add customer -----------"

        new_customers = self.state['e'].get_next_arriving_customers()

        if DEBUG:
            print " {0} customers to be added.".format(len(new_customers))

        # send customer count
        write_data = sp.pack_single_uint8(len(new_customers))

        # send all customers on new_customers list
        for c in new_customers:
            if DEBUG:
                print " packing customer {0}".format(c.id)
            write_data += sp.pack_single_uint32(c.id)

        self.write(write_data)

        # add all customers on new_customers list to waiting_list
        # try to seat all customers on waiting_list at empty tables
        seated_cnt = self.state['e'].seat_customers(new_customers)

        # recv number of customers seated
        if DEBUG:
            print " {0} seated".format(seated_cnt)

        recv_buf = recv_uint8(seated_cnt)

        recv_buf += recv_status(self.STATUS_OK)
        self.read(length=len(recv_buf), expect=recv_buf)

        return 0
예제 #32
0
    def set_deceased(self):
        '''
        Set a person as deceased
        '''
        if DEBUG:
            print "cmd: set deceased -----------"

        [parent1] = self.state['s'].get_random_people(1)
        if self.state['s'].p_unk == parent1:
            # no people
            return -1

        buf = parent1.get_id_bytes()
        buf += parent1.get_death_date_bytes()
        buf = self.SET_DECEASED + sp.pack_single_uint32(len(buf)) + buf
        self.write(buf)

        ret = self.state['s'].set_deceased(parent1)
        if 0 != ret:
            self.read(length=len(self.ERR))
            return -1

        self.read(length=len(self.OK))
        return 0
예제 #33
0
    def get_refund(self):
        '''
        Get tax refund.
        '''
        if DEBUG:
            print "cmd: get refund"

        s_invalid = False
        s = self._get_random_session()
        p_invalid = False
        years = []
        refund = 0

        if None == s:
            # create invalid session to trigger fail paths
            tp = self._gen_random_taxpayer()

            s_key = sp.random_string(12)
            s = Session(s_key, tp, self.GET_REFUND, "")
            s_invalid = True
        else:
            tp = self.state['s'].get_taxpayer_by_username(s.username)
            refund, years = tp.get_list_refund()
            if [] == years:
                p_invalid = True

            s = Session(s.key, tp, self.GET_REFUND, "")

        if DEBUG:
            print "refund {0} years: {1}".format(refund, years)

        buf = s.gen_bytes()
        self.write(buf)

        res = self.OK
        ans = self.TAXES_DUE_OK
        if True == s_invalid:
            res = self.ERR
            ans = self.NICE_TRY
        elif True == p_invalid:
            res = self.ERR
            ans = self.GET_REFUND_FAIL
        else:
            ans = self.GET_REFUND_OK + sp.pack_single_uint32(refund) + ''.join(
                [sp.pack_single_uint16(y) for y in years])

        resp = Response(s.key, ans, res)
        if DEBUG:
            print resp

        buf = resp.gen_bytes()

        if DEBUG:
            print " Username: {0}".format(tp.username)
            print " Response: K:{0}, A:{1}, R:{2} {3}".format(
                len(resp.s_key), len(resp.answer), len(resp.result), resp)

        buf = resp.gen_bytes()

        if DEBUG:
            print " resp buf: ({0}) {1}".format(len(buf), sp.hexify(buf))
            print "         as text {0}".format(buf)

        if res == self.ERR:
            # cannot match key on ERR conditions, so just read len
            e = buf[:len(resp.s_key)]
            buf = buf[len(resp.s_key):]
            self.read(length=len(e))
            if DEBUG:
                print " read resp.s_key = ({0}) {1}".format(
                    len(e), sp.hexify(e))
                print "  new buf {0}".format(sp.hexify(buf))

            e = buf[:len(resp.answer)]
            buf = buf[len(resp.answer):]
            self.read(length=len(e), expect=e)
            if DEBUG:
                print " read resp.answer = ({0}) {1}".format(
                    len(e), sp.hexify(e))
                print "  new buf {0}".format(sp.hexify(buf))

        else:
            e = buf[:len(resp.s_key) + len(resp.answer)]
            buf = buf[len(resp.s_key) + len(resp.answer):]
            self.read(length=len(e), expect=e)
            if DEBUG:
                print " read resp.s_key + resp.answer = ({0}) {1}".format(
                    len(e), sp.hexify(e))
                print "  new buf {0}".format(sp.hexify(buf))

        # we've read the key and answer, the rest of the answer bytes are
        # junk, so just read len
        e = buf[:-len(resp.result)]
        buf = buf[-len(resp.result):]
        self.read(length=len(e))
        if DEBUG:
            print " read -len(resp.result) = ({0}) {1}".format(
                len(e), sp.hexify(e))
            print "  new buf {0}".format(sp.hexify(buf))

        self.read(length=len(buf), expect=buf)
        if DEBUG:
            print " read final len(buf) = ({0}) {1}".format(
                len(buf), sp.hexify(buf))

        return 0
예제 #34
0
 def get_id_bytes(self):
     return sp.pack_single_uint32(self.id)
예제 #35
0
def recv_uint32(val):
    return sp.pack_single_uint32(val)
예제 #36
0
 def recv_uint32(self, val, match=True):
     if True == match:
         self.read(length=4, expect=sp.pack_single_uint32(val))
     else:
         self.read(length=4)
예제 #37
0
 def get_serialized_content(self):
     sc = ''
     sc += sp.pack_single_uint32(self.serialVersionUID)
     sc += sp.pack_single_string(self.typeName)
     sc += sp.pack_single_uint32(self.subTypeID)
     return sc
예제 #38
0
 def get_plain_content(self):
     pc = ''
     pc += sp.pack_single_uint32(self.serialVersionUID)
     pc += sp.pack_single_uint8(self.subTypeID)
     return pc
예제 #39
0
 def get_plain_content(self):
     pc = ''
     pc += sp.pack_single_uint32(self.serialVersionUID)
     pc += sp.pack_single_string(self.str)
     pc += sp.pack_single_char('\0')
     return pc
예제 #40
0
    def get_refund(self):
        '''
        Get tax refund.
        '''
        if DEBUG:
            print "cmd: get refund"

        s_invalid = False
        s = self._get_random_session()
        p_invalid = False
        years = []
        refund = 0

        if None == s:
            # create invalid session to trigger fail paths
            tp = self._gen_random_taxpayer()

            s_key = sp.random_string(12)
            s = Session(s_key, tp, self.GET_REFUND, "")
            s_invalid = True
        else:
            tp = self.state['s'].get_taxpayer_by_username(s.username)
            refund, years = tp.get_list_refund()
            if [] == years:
                p_invalid = True

            s = Session(s.key, tp, self.GET_REFUND, "")

        if DEBUG:
            print "refund {0} years: {1}".format(refund, years)

        buf = s.gen_bytes()
        self.write(buf)

        res = self.OK
        ans = self.TAXES_DUE_OK
        if True == s_invalid:
            res = self.ERR
            ans = self.NICE_TRY
        elif True == p_invalid:
            res = self.ERR
            ans = self.GET_REFUND_FAIL
        else:
            ans = self.GET_REFUND_OK + sp.pack_single_uint32(refund) + ''.join(
                [sp.pack_single_uint16(y) for y in years])

        resp = Response(s.key, ans, res)
        if DEBUG:
            print resp

        buf = resp.gen_bytes()
        if res == self.ERR:
            # cannot match key on ERR conditions, so trim
            # it and assign it to regex
            self.read(length=len(resp.s_key), assign=self.state['randkey'])
            buf = buf[len(resp.s_key):]
            self.read(length=len(resp.answer))
            buf = buf[len(resp.answer):]
        else:
            st = buf[:len(resp.s_key) + len(resp.answer)]
            self.read(length=len(st))
            buf = buf[len(resp.s_key) + len(resp.answer):]

        # we've read the key and answer, the rest of the answer bytes are
        # junk, so ignore them.
        self.read(length=len(buf) - len(resp.result))
        # read result
        buf = buf[len(buf) - len(resp.result):]
        self.read(length=len(buf))

        return 0
예제 #41
0
    def gen_totals_and_ds(self):
        ident = self.id_num
        income = self.wages + self.interest + self.biz_income + self.retirement_income
        expenses = self.biz_expenses + self.edu_expenses + self.self_employ_expenses
        credits = self.edu_credits + self.child_credits + self.retirement_credits + self.home_buyer_credits
        payments = self.tax_withheld + self.tax_paid_non_taxable_income

        base_tax = 12345
        taxable_income = (income >> 3)
        expense_deduction = (expenses >> 4)
        credit_deduction = (credits >> 2)
        total_tax_owed = base_tax + self.amount + taxable_income - expense_deduction - credit_deduction - payments

        # if DEBUG:
        #     print " total_tax_owed: {0} = {1} + {2} + {3} - {4} - {5} - {6}". \
        #         format(total_tax_owed, base_tax, self.amount, taxable_income, expense_deduction, credit_deduction, payments)

        if 0 < total_tax_owed:
            self.tax_due = total_tax_owed
        else:
            self.tax_refund = -total_tax_owed

        l_ident = list(sp.pack_single_uint32(ident))
        l_income = list(sp.pack_single_int64(income))
        l_expenses = list(sp.pack_single_int64(expenses))
        l_credits = list(sp.pack_single_int64(credits))
        l_payments = list(sp.pack_single_int64(payments))

        self.digital_signature[0] = ord(l_ident[0]) ^ ord(self.fname[0])
        self.digital_signature[1] = ord(l_ident[1]) ^ ord(self.mname[0])
        self.digital_signature[2] = ord(l_ident[2]) ^ ord(self.lname[1])
        self.digital_signature[3] = ord(l_ident[3]) ^ ord(self.addy[1])
        self.digital_signature[4] = ord(self.csz[0]) ^ ord(self.fname[1])
        self.digital_signature[5] = ord(self.csz[1]) ^ ord(self.mname[1])
        self.digital_signature[6] = ord(self.csz[2]) ^ ord(self.lname[2])
        self.digital_signature[7] = ord(self.csz[3]) ^ ord(self.addy[2])

        self.digital_signature[4] ^= ord(l_income[0])
        self.digital_signature[5] ^= ord(l_income[1])
        self.digital_signature[6] ^= ord(l_income[2])
        self.digital_signature[7] ^= ord(l_income[3])
        self.digital_signature[8] = ord(l_income[4])
        self.digital_signature[9] = ord(l_income[5])
        self.digital_signature[10] = ord(l_income[6])
        self.digital_signature[11] = ord(l_income[7])

        self.digital_signature[8] ^= ord(l_expenses[0])
        self.digital_signature[9] ^= ord(l_expenses[1])
        self.digital_signature[10] ^= ord(l_expenses[2])
        self.digital_signature[11] ^= ord(l_expenses[3])
        self.digital_signature[12] = ord(l_expenses[4])
        self.digital_signature[13] = ord(l_expenses[5])
        self.digital_signature[14] = ord(l_expenses[6])
        self.digital_signature[15] = ord(l_expenses[7])

        self.digital_signature[12] ^= ord(l_credits[0])
        self.digital_signature[13] ^= ord(l_credits[1])
        self.digital_signature[14] ^= ord(l_credits[2])
        self.digital_signature[15] ^= ord(l_credits[3])
        self.digital_signature[16] = ord(l_credits[4])
        self.digital_signature[17] = ord(l_credits[5])
        self.digital_signature[18] = ord(l_credits[6])
        self.digital_signature[19] = ord(l_credits[7])

        self.digital_signature[16] ^= ord(l_payments[0])
        self.digital_signature[17] ^= ord(l_payments[1])
        self.digital_signature[18] ^= ord(l_payments[2])
        self.digital_signature[19] ^= ord(l_payments[3])
        self.digital_signature[20] = ord(l_payments[4]) ^ ord(self.fname[3])
        self.digital_signature[21] = ord(l_payments[5]) ^ ord(self.mname[4])
        self.digital_signature[22] = ord(l_payments[6]) ^ ord(self.lname[5])
        self.digital_signature[23] = ord(l_payments[7]) ^ ord(self.addy[6])

        self.digital_signature = [chr(x) for x in self.digital_signature]

        self.submission_date = sp.random_digits(8)
        while "00000000" == self.submission_date:
            self.submission_date = sp.random_digits(8)
예제 #42
0
 def generate_load_buffer(self):
     '''
     decider tuple (ID, altitude)
     '''
     return sp.pack_single_uint32(self.id) + sp.pack_single_uint32(self.altitude)
예제 #43
0
    def get_stats(self):
        if DEBUG:
            print self.__str__()

        return sp.pack_single_uint32(self.id) + sp.pack_single_uint32(self.energy_level)
예제 #44
0
    def gen_bytes(self):
        '''
        Generate byte string sent for a TenFourD.
        '''
        byte_str = sp.pack_single_uint16(self.tax_year)
        for v in [self.fname, self.mname, self.lname, self.addy, self.csz]:
            byte_str += sp.pack_single_string(v)
        byte_str += sp.pack_single_uint32(self.id_num)

        byte_str += sp.pack_single_char(self.donate)
        byte_str += sp.pack_single_uint32(self.amount)
        byte_str += sp.pack_single_uint32(self.party)

        byte_str += sp.pack_single_uint32(self.wages)
        byte_str += sp.pack_single_uint32(self.interest)
        byte_str += sp.pack_single_uint32(self.biz_income)
        byte_str += sp.pack_single_uint32(self.retirement_income)

        byte_str += sp.pack_single_uint32(self.biz_expenses)
        byte_str += sp.pack_single_uint32(self.edu_expenses)
        byte_str += sp.pack_single_uint32(self.self_employ_expenses)

        byte_str += sp.pack_single_uint32(self.edu_credits)
        byte_str += sp.pack_single_uint32(self.child_credits)
        byte_str += sp.pack_single_uint32(self.retirement_credits)
        byte_str += sp.pack_single_uint32(self.home_buyer_credits)

        byte_str += sp.pack_single_uint32(self.tax_withheld)
        byte_str += sp.pack_single_uint32(self.tax_paid_non_taxable_income)

        byte_str += sp.pack_single_string(''.join(self.digital_signature))
        byte_str += sp.pack_single_string(self.submission_date)
        byte_str += sp.pack_single_uint32(self.tax_due)
        byte_str += sp.pack_single_uint32(self.tax_refund)

        return byte_str
예제 #45
0
 def generate_load_buffer(self):
     '''
     rider tuple (ID, type, energy_level, health_code)
     '''
     return sp.pack_single_uint32(self.id) + sp.pack_single_uint32(self.type) + \
             sp.pack_single_uint32(self.energy_level) + sp.pack_single_uint32(self.health_code)