Пример #1
0
	def listen(self, host):
		sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
		sock.connect((host, SERVICE_PORT))
		port = Port(sock)
		port.write(self.subs)
		while True:
			res = port.read()
			if res:
				self.queue.put(res)
Пример #2
0
 def listen_telescreens(self, listen_port):
     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
     sock.bind(("", listen_port))
     sock.listen(10000)
     while True:
         client_sock, _ = sock.accept()
         port = Port(client_sock)
         uuid = port.read()
         self.telescreens[uuid] = port
Пример #3
0
class Source(object):
	def __init__(self, host):
		sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
		sock.connect((host, SERVICE_PORT))
		self.port = Port(sock)

	def sendall(self, list):
		for item in list:
			self.port.write(item)

	def send(self, item):
		self.port.write(item)
Пример #4
0
Файл: nat.py Проект: wil/pyroman
	def __init__(self, client, server, ip, port, dport, dir, loginfo):
		"""
		Create a new NAT rule

		client -- clients allowed to access this NAT rule
		server -- host nick the NAT is applied to
		ip -- IP that is used in NAT
		port -- Ports that are used in NAT
		dport -- Destination port for single port redirections
		dir -- incoming, outgoing or bidirecitonal NAT

		Note that the NAT is always applied to the "server" host, the UI
		accessible function is responsible to eventually exchange client
		and server for "outgoing" NATs (where the naming of client, server
		makes more sense the other way, think of workstations accessing
		web server via a NAT)
		"""
		if server == "":
			raise PyromanException("Nat lacking a server host (client: %s, server: %s, ip: %s) at %s" % (client, server, ip, loginfo))
		if ip == "":
			raise PyromanException("Nat lacking IP address: (client: %s, server: %s) at %s" % (client, server, loginfo))
		if dir not in ["in", "out", "both"]:
			raise PyromanException("Nat with invalid direction: (client: %s, server: %s, ip: %s, dir: %s) at %s" % (client, server, ip, dir, loginfo))
		if not Util.verify_ip4(ip):
			raise PyromanException("Nat with invalid IP address: (client: %s, server: %s, ip: %s) at %s" % (client, server, ip, loginfo))
		if port:
			try:
				self.port = Port(port)
			except PortInvalidSpec:
				raise PyromanException("Nat port specification invalid: (client: %s, server: %s, ip: %s, port: %s) at %s " % (client, server, ip, port, loginfo))
			if not self.port.forIPv4():
				raise PyromanException("Non-IPv4 port specified: "+port)
		else:
			self.port = None
		if dport:
			try:
				self.dport = Port(dport)
			except PortInvalidSpec:
				raise PyromanException("Nat dport specification invalid: (client: %s, server: %s, ip: %s, port: %s, dport: %s) at %s " % (client, server, ip, port, dport, loginfo))
			if not self.dport.forIPv4():
				raise PyromanException("Non-IPv4 port specified: "+dport)
		else:
			self.dport = None
		if self.dport and not (self.port.proto == self.dport.proto):
			raise PyromanException("Nat ports have different protocols: (client: %s, server: %s, ip: %s, port: %s, dport: %s) at %s" % (client, server, ip, port, dport, loginfo))
		if dport and not port:
			raise PyromanException("Nat with destination port, but no source port: (client: %s, server: %s, ip: %s, dport: %s) at %s" % (client, server, ip, dport, loginfo))
		self.client = Util.splitter.split(client)
		self.server = Util.splitter.split(server)
		self.ip = ip
		# port, dport are set above
		self.dir = dir
		self.loginfo = loginfo
Пример #5
0
 def start_tunnel(self):
     if self is not currentThread():
         self._send_cmd('start')
         return
     self._op_lock.acquire()
     try:
         self.is_active = 1
         # set up Port object for the tunnel that reads\writes to the 
         # slave device file of the pseudo-terminal pair. 
         if not self._serial_port:
             self._serial_port = Port()
         cfg = self._vcp.configuration()
         cfg['dev'] = self.tty
         cfg['name'] = '_slave'
         cfg['parent'] = self._vcp
         self._serial_port.configure(cfg)
         self._op_lock.release()
     except:
         self._op_lock.release()
     while self.is_active:
         if not self._serial_port.is_open():
             self._serial_port.open()
             self._serial_port.drain()
         try:
             if self.is_server:
                 self._do_listen()
             else:
                 self._do_connect()
         except:
             msglog.exception()
             if self._serial_port and not self._serial_port.is_open():
                 self._serial_port.close()
Пример #6
0
 def port_scan(self):
     """ Scan range of ports """
     scan_ports = list(Port.ports_list(self.address[1]))
     random.shuffle(scan_ports)
     for port in scan_ports:
         self.ports[port] = Port(self.address[0], port)
         print(self.ports[port])
     return self.ports
Пример #7
0
 def _finish_init_(self):
     for p in self._obj.ports:
         self._children.append(Port.getPort(p, self, self._outbox))
     for prop in self._obj._propertySet:
         try:
             pp = Property(prop, self, self._outbox)
             self._children.append(pp)
         except:
             pass
Пример #8
0
    def parse(tkns):
        """ Parse a verilog module
            module :=
                'module' identifier [module_param_port_list] [list_of_ports]
                    ';' {module_item} 'endmodule'
                | 'module' identifier [module_param_port_list]
                    [list_of_port_declarations] ';' {non_port_module_item}
                    'endmodule'
        """
        tkns.expect(Tokens.KW_MODULE)

        # get module name
        name = tkns.current().text
        tkns.expect(Tokens.IDENTIFIER)

        # get parameter port list, if it exists
        params = []
        if tkns.check(Tokens.HASH):
            params = Parameter.parse_module_param_port_list(tkns)

        # get i/o port list, if it exists
        io = []
        if tkns.check(Tokens.OPEN_PAREN):
            if tkns.peek(Tokens.CLOSE_PAREN):
                tkns.next()
                tkns.next()
            elif tkns.peek(Tokens.KW_INOUT) or tkns.peek(Tokens.KW_INPUT) or tkns.peek(Tokens.KW_OUTPUT):
                io = Port.parse_list_of_port_declarations(tkns)
            else:
                io = Port.parse_list_of_ports(tkns)

        # get module contents
        # TODO: look at contents for more parameters, do other parsing
        contents = []
        while not tkns.accept(Tokens.KW_ENDMODULE):
            contents.append(tkns.next())

        return Module(name, params, io, contents)
Пример #9
0
def port_parser(dp_id, p_identifier, port_conf, vlans):
    port = Port(p_identifier, port_conf)

    if port.mirror is not None:
        # ignore other config
        return port
    if port.native_vlan is not None:
        v_identifier = port.native_vlan
        vlan = _get_vlan_by_identifier(dp_id, v_identifier, vlans)
        vlan.add_untagged(port)
    for v_identifier in port.tagged_vlans:
        vlan = _get_vlan_by_identifier(dp_id, v_identifier, vlans)
        vlan.add_tagged(port)

    return port
Пример #10
0
def port_parser(dp_id, p_identifier, port_conf, vlans):
    port = Port(p_identifier, port_conf)

    if port.mirror is not None:
        # ignore other config
        return port
    if port.native_vlan is not None:
        v_identifier = port.native_vlan
        vlan = vlans.setdefault(v_identifier, VLAN(v_identifier, dp_id))
        vlan.untagged.append(port)
    for v_identifier in port.tagged_vlans:
        vlan = vlans.setdefault(v_identifier, VLAN(v_identifier, dp_id))
        vlan.tagged.append(port)

    return port
Пример #11
0
    def parse_ryu_switches(self):

        ryu_switches = None

        with open(self.network_configuration.conf_path + "ryu_switches.json",
                  "r") as in_file:
            ryu_switches = json.loads(in_file.read())

        #  Go through each node and grab the ryu_switches and the corresponding hosts associated with the switch
        for dpid in ryu_switches:

            #  prepare a switch id
            switch_id = "s" + str(dpid)

            # Check to see if a switch with this id already exists in the graph,
            # if so grab it, otherwise create it
            sw = self.get_node_object(switch_id)
            if not sw:
                sw = Switch(switch_id, self)
                self.graph.add_node(switch_id, node_type="switch", sw=sw)
                self.switch_ids.append(switch_id)

            # Parse out the information about all the ports in the switch
            switch_ports = {}
            for port in ryu_switches[dpid]["ports"]:
                if port["port_no"] == 4294967294:
                    continue

                if port["port_no"] == "LOCAL":
                    continue

                switch_ports[int(port["port_no"])] = Port(sw, port_json=port)

            sw.ports = switch_ports

            # Parse group table if one is available
            if "groups" in ryu_switches[dpid]:
                sw.group_table = GroupTable(sw, ryu_switches[dpid]["groups"])

            # Parse all the flow tables and sort them by table_id in the list
            switch_flow_tables = []
            for table_id in ryu_switches[dpid]["flow_tables"]:
                switch_flow_tables.append(
                    FlowTable(sw, table_id,
                              ryu_switches[dpid]["flow_tables"][table_id]))
                sw.flow_tables = sorted(
                    switch_flow_tables,
                    key=lambda flow_table: flow_table.table_id)
Пример #12
0
    def __init__(self):
        super(PiInterface, self).__init__(40)
        for number in range(1, 41):
            if number not in self._FORBIDDEN:
                self._ports[number] = Port(self, number)

        # Defines the pull up or pull down rezistor for inputs.
        # Possible values are:
        # 1. self.PULL_UP
        # 2. self.PULL_DOWN
        # 3. None (input fluctuating by default)
        self.pull_up_down_rezistor = self.PULL_UP

        self._port_listeners = {}

        self._initialize_ports()
Пример #13
0
    def get_ports(self, refresh=False):
        """
        Get all ports on this OVS node

        :param refresh: (boolean) If true, force refresh of all items
        :return: (list) of port nodes
        """
        if not refresh and self._ports is not None:
            return self._ports

        self._ports = Port.get_ports(parent=self,
                                     port_ids=self.metadata['ports'],
                                     address=self.ssh_address,
                                     ssh_credentials=self._ssh_credentials,
                                     ovs_topology=self.ovs_topology)
        return self._ports
Пример #14
0
    def parse_onos_switches(self):

        onos_switches = None

        with open(self.network_configuration.conf_path + "onos_switches.json",
                  "r") as in_file:
            onos_switches = json.loads(in_file.read())

        for onos_switch in onos_switches["devices"]:

            #  prepare a switch id
            switch_id = self.onos_sw_device_id_to_node_id_mapping(
                onos_switch["id"])

            # Check to see if a switch with this id already exists in the graph,
            # if so grab it, otherwise create it
            sw = self.get_node_object(switch_id)
            if not sw:
                sw = Switch(switch_id, self)
                self.graph.add_node(switch_id, node_type="switch", sw=sw)
                self.switch_ids.append(switch_id)

            # Parse out the information about all the ports in the switch
            switch_ports = {}
            for port_num in onos_switch["ports"]:
                switch_ports[int(port_num)] = Port(
                    sw, port_json=onos_switch["ports"][port_num])

            sw.ports = switch_ports

            # Parse group table if one is available
            if "groups" in onos_switch:
                sw.group_table = GroupTable(sw, onos_switch["groups"])

            # Parse all the flow tables and sort them by table_id in the list
            switch_flow_tables = []
            for table_id in onos_switch["flow_tables"]:
                switch_flow_tables.append(
                    FlowTable(sw, table_id,
                              onos_switch["flow_tables"][table_id]))
                sw.flow_tables = sorted(
                    switch_flow_tables,
                    key=lambda flow_table: flow_table.table_id)
Пример #15
0
    def parse_onos_switches(self, onos_switches):

        for onos_switch in onos_switches["devices"]:

            if not onos_switch["available"]:
                continue

            #  prepare a switch id
            switch_id = self.onos_sw_device_id_to_node_id_mapping(
                onos_switch["id"])

            # Check to see if a switch with this id already exists in the graph,
            # if so grab it, otherwise create it
            sw = self.get_node_object(switch_id)
            if not sw:
                sw = Switch(switch_id, self)
                self.graph.add_node(switch_id, node_type="switch", sw=sw)
                self.switch_ids.append(switch_id)

            # Parse out the information about all the ports in the switch
            switch_ports = {}
            for port_json in onos_switch["ports"]:
                if port_json["port"] == "local":
                    continue
                switch_ports[int(port_json["port"])] = Port(sw,
                                                            port_raw=port_json)

            sw.ports = switch_ports

            # Parse group table if one is available
            if "groups" in onos_switch:
                sw.group_table = GroupTable(sw, onos_switch["groups"])

            # Parse all the flow tables and sort them by table_id in the list
            switch_flow_tables = []
            for table_id in onos_switch["flow_tables"]:
                switch_flow_tables.append(
                    FlowTable(sw, table_id,
                              onos_switch["flow_tables"][table_id]))
                sw.flow_tables = sorted(
                    switch_flow_tables,
                    key=lambda flow_table: flow_table.table_id)
Пример #16
0
    def switch_feature_handler(self, event):
        """
            event handler when receiving feature information
            from switch.
        """
        dpid = event.msg.datapath_id
        try:
            switch = self.switches[dpid]
        except KeyError:
            self.switches[dpid] = Switch(event.msg.datapath, self.switches)
            switch = self.switches[dpid]

        for port_no, port in event.msg.ports.iteritems():
            if port_no not in switch.ports:
                p = Port(port=port, datapath=event.msg.datapath)
                switch.ports[port_no] = p

            p = switch.ports[port_no]

            if port_no == ofproto_v1_0.OFPP_LOCAL:
                switch.name = port.name.rstrip('\x00')
Пример #17
0
    def parse_grpc_switches(self, grpc_switches):

        #  Go through each node and grab the ryu_switches and the corresponding hosts associated with the switch
        for switch in grpc_switches:

            # Check to see if a switch with this id already exists in the graph,
            # if so grab it, otherwise create it
            sw = self.get_node_object(switch.switch_id)
            if not sw:
                sw = Switch(switch.switch_id, self)
                self.graph.add_node(switch.switch_id,
                                    node_type="switch",
                                    sw=sw)
                self.switch_ids.append(switch.switch_id)

            # Parse out the information about all the ports in the switch
            switch_ports = {}
            for port in switch.ports:
                if port.port_num == 4294967294:
                    continue

                if port.port_num == "LOCAL":
                    continue

                switch_ports[int(port.port_num)] = Port(sw, port_raw=port)

            sw.ports = switch_ports

            # Parse group table if one is available
            if len(switch.group_table) > 0:
                sw.group_table = GroupTable(sw, switch.group_table)

            # Parse all the flow tables and sort them by table_id in the list
            switch_flow_tables = []
            for flow_table in switch.flow_tables:
                switch_flow_tables.append(
                    FlowTable(sw, flow_table.table_num, flow_table))
                sw.flow_tables = sorted(
                    switch_flow_tables,
                    key=lambda flow_table: flow_table.table_id)
Пример #18
0
    def logic(self):
        nr_containers = totContainers()
        port = Port("PiraeusPier2", nr_containers)
        threads = []
        groups = []
        nr_groups = 13
        colours = []
        colours.append(pygame.Color(228, 197, 73))
        colours.append(pygame.Color(185, 0, 37))
        colours.append(pygame.Color(78, 87, 111))
        colours.append(pygame.Color(12, 63, 50))
        colours.append(pygame.Color(236, 110, 0))
        colours.append(pygame.Color(68, 22, 33))
        colours.append(pygame.Color(143, 149, 160))
        colours.append(pygame.Color(185, 197, 201))
        colours.append(pygame.Color(35, 127, 125))
        colours.append(pygame.Color(149, 132, 103))
        colours.append(pygame.Color(0, 44, 125))
        colours.append(pygame.Color(0, 160, 213))
        colours.append(pygame.Color(166, 202, 87))
        colours.append(pygame.Color(228, 166, 156))

        for i in range(nr_groups - port.nr_docks):
            groups.append(Group(i, port, "outbound", nr_containers,
                                colours[i]))
        for i in range(nr_groups - port.nr_docks, nr_groups):
            groups.append(Group(i, port, "inbound", nr_containers, colours[i]))
        info = InfoPanel(port, groups)
        for i in range(nr_groups):
            thread = Thread(target=groups[i].manage, name=str(i), daemon=True)
            threads.append(thread)
        """info = Thread(target = info.give_info, name = str(nr_groups + 1), daemon = True)
        threads.append(info)"""
        for t in threads:
            t.start()
        graphics = Graphics(port, groups)
        graphics.display()
        while True:
            pass
Пример #19
0
    def scanIp(self, Ip, Mac):
        # if Mac is None:
        # 	Mac = getmacbyip(Ip)
        self.nm.scan(Ip, '1-200')
        ports = []
        for protocol in self.nm[Ip].all_protocols():
            lport = self.nm[Ip][protocol].keys()
            lport.sort()
            for port in lport:
                name = self.nm[Ip][protocol][port]['name']
                state = self.nm[Ip][protocol][port]['state']
                product = self.nm[Ip][protocol][port]['product']
                p = Port(port, name, state, product, protocol)
                ports.append(p)
        m = Machine(Ip, Mac, ports)
        if 'hostnames' in self.nm[Ip]:
            m.hostname = self.nm[Ip]['hostnames']

        so, accuracy = self.findSO(m)
        m.so = so
        m.accuracy = accuracy
        self.lmachine.append(m)
Пример #20
0
    def __init__(self, path=None):
        """ The ``Device`` class represents a device.

        Args:
            path (str): path to a model yaml file.
        """
        self.name = None
        self.ports = []

        if path != None:
            model = util.load_yaml_file(path)
            
            # Load name from device model file
            if 'name' in model:
                self.name = model['name']

            # Load ports from device model file
            for port_model in model['ports']:
                port = Port(port_model['number'])

                # Parse port state space:
                # 1. search for 'mode', 'direction', 'voltage' (a) values or (b) lists of values
                # 2. search for 'states' list

                if 'mode' in port_model and 'direction' in port_model and 'voltage' in port_model:
                    state = {}
                    state['mode'] = [port_model['mode']]
                    state['direction'] = [port_model['direction']]
                    state['voltage'] = [port_model['voltage']]
                    port.states.append(state)

                elif 'states' in port_model:
                    for state in port_model['states']:
                        port.states.append(state)
                        #print state['mode']
                        #print state['direction']
                        #print state['voltage']

                self.ports.append(port)
Пример #21
0
class Agent(object):
	def __init__(self, addr):
		sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
		sock.connect(addr)
		self.port = Port(sock)

	def list(self):
		self.port.write("?")
		return json.loads(self.port.read())

	def fetch(self, want="*"):
		if want == "*":
			req = "*"
		else:
			req = json.dumps(want)
		self.port.write(req)
		return json.loads(self.port.read())
Пример #22
0
    def __init__(self, address):
        """
        Creates new instance of interface with some address defined by I2C.
        It DOES NOT validate if an interface instance with the same address
        was already created.

        :param address: Address of I2C interface, eg. 0x20.
        """
        super(MCP23017, self).__init__(16)
        self._address = address

        # _MCP23017ListenerThread
        self._read_events_thread = None

        # Determines if pull up rezistor should be set for inputs.
        # If False nothing will be set, so by default input will be
        # fluctuating.
        self.use_pullup_rezistor = True

        for number in range(1, 17):
            self._ports[number] = Port(self, number)

        _REGISTRY.append(self)
        self._initialize_ports()
Пример #23
0
 def createContainer(self):
     port = Port()
     newPort = port.getNewPort()
     sp.getoutput(
         "sudo docker run -dit -p {}:4200  paas:v1".format(newPort))
     return newPort
Пример #24
0
 def __init__(self, direction, protocol, port, ip):
     self._direction = direction
     self._protocol = protocol
     self._port = Port(port)
     self._ip = Ip(ip)
Пример #25
0
 def SetOutport(self, ptups):
     vecs = []
     for ptup in ptups:
         vecs.append(self.prims[ptup[0]].vertices[ptup[1]])
     self.outports.append(Port(vecs))
Пример #26
0
 def port(self):
     return Port(self.client)
Пример #27
0
    def _packet_in_handler(self, ev):
        msg = ev.msg
        dp = msg.datapath
        ofproto = dp.ofproto
        parser = dp.ofproto_parser

        pkt = packet.Packet(msg.data)
        ethernet_proto = pkt.get_protocols(ethernet.ethernet)[0]

        src = ethernet_proto.src
        dst = ethernet_proto.dst
        eth_type = ethernet_proto.ethertype

        in_port = msg.match['in_port']
        self.mac_to_port.setdefault(dp.id, {})

        # Configure logging to include datapath id
        self.set_dpid_log_formatter(dp.id)

        if dp.id not in self.dps:
            self.logger.error("Packet_in on unknown datapath")
            self.set_default_log_formatter()
            return
        else:
            datapath = self.dps[dp.id]

        if not datapath.running:
            self.logger.error("Packet_in on unconfigured datapath")

        if in_port not in datapath.ports:
            self.set_default_log_formatter()
            return

        if eth_type == ether.ETH_TYPE_8021Q:
            # tagged packet
            vlan_proto = pkt.get_protocols(vlan.vlan)[0]
            vid = vlan_proto.vid
            if Port(in_port, 'tagged') not in datapath.vlans[vid].tagged:
                self.logger.warn("HAXX:RZ in_port:%d isn't tagged on vid:%s" % \
                    (in_port, vid))
                self.set_default_log_formatter()
                return
        else:
            # untagged packet
            vid = datapath.get_native_vlan(in_port).vid
            if not vid:
                self.logger.warn("Untagged packet_in on port:%d without native vlan" % \
                        (in_port))
                self.set_default_log_formatter()
                return

        self.mac_to_port[dp.id].setdefault(vid, {})

        self.logger.info("Packet_in src:%s dst:%s in_port:%d vid:%s", src, dst,
                         in_port, vid)

        # learn a mac address to avoid FLOOD next time.
        self.mac_to_port[dp.id][vid][src] = in_port

        # generate the output actions for broadcast traffic
        tagged_act = self.tagged_output_action(parser,
                                               datapath.vlans[vid].tagged)
        untagged_act = self.untagged_output_action(
            parser, datapath.vlans[vid].untagged)

        matches = []
        action = []
        if datapath.ports[in_port].is_tagged():
            # send rule for mathcing packets arriving on tagged ports
            strip_act = [parser.OFPActionPopVlan()]
            if tagged_act:
                action += tagged_act
            if untagged_act:
                action += strip_act + untagged_act

            matches.append(
                parser.OFPMatch(vlan_vid=vid | ofproto_v1_3.OFPVID_PRESENT,
                                in_port=in_port,
                                eth_src=src,
                                eth_dst='ff:ff:ff:ff:ff:ff'))

            matches.append(
                parser.OFPMatch(vlan_vid=vid | ofproto_v1_3.OFPVID_PRESENT,
                                in_port=in_port,
                                eth_src=src,
                                eth_dst=('01:00:00:00:00:00',
                                         '01:00:00:00:00:00')))
        elif datapath.ports[in_port].is_untagged():
            # send rule for each untagged port
            push_act = [
                parser.OFPActionPushVlan(ether.ETH_TYPE_8021Q),
                parser.OFPActionSetField(vlan_vid=vid
                                         | ofproto_v1_3.OFPVID_PRESENT)
            ]
            if untagged_act:
                action += untagged_act
            if tagged_act:
                action += push_act + tagged_act

            matches.append(
                parser.OFPMatch(in_port=in_port,
                                eth_src=src,
                                eth_dst='ff:ff:ff:ff:ff:ff'))

            matches.append(
                parser.OFPMatch(in_port=in_port,
                                eth_src=src,
                                eth_dst=('01:00:00:00:00:00',
                                         '01:00:00:00:00:00')))

        # install broadcast/multicast rules onto datapath
        if datapath.config_default['smart_broadcast']:
            for match in matches:
                priority = datapath.config_default['low_priority']
                cookie = datapath.config_default['cookie']
                self.add_flow(dp, match, action, priority, cookie)

        # install unicast flows onto datapath
        if dst in self.mac_to_port[dp.id][vid]:
            # install a flow to avoid packet_in next time
            out_port = self.mac_to_port[dp.id][vid][dst]
            if out_port == in_port:
                self.logger.info("in_port is the same as out_port, skipping unicast flow " \
                        "dl_dst:%s dl_src:%s vid:%d", dst, src, vid)
                self.set_default_log_formatter()
                return

            self.logger.info("Adding unicast flow dl_dst:%s vid:%d", dst, vid)

            actions = []

            if datapath.ports[in_port].is_tagged():
                match = parser.OFPMatch(in_port=in_port,
                                        eth_src=src,
                                        eth_dst=dst,
                                        vlan_vid=vid
                                        | ofproto_v1_3.OFPVID_PRESENT)
                if datapath.ports[out_port].is_untagged():
                    actions.append(parser.OFPActionPopVlan())
            if datapath.ports[in_port].is_untagged():
                match = parser.OFPMatch(in_port=in_port,
                                        eth_src=src,
                                        eth_dst=dst)
                if datapath.ports[out_port].is_tagged():
                    actions.append(parser.OFPActionPushVlan())
                    actions.append(
                        parser.OFPActionSetField(
                            vlan_vid=vid | ofproto_v1_3.OFPVID_PRESENT))
            actions.append(parser.OFPActionOutput(out_port))

            priority = datapath.config_default['high_priority']
            cookie = datapath.config_default['cookie']
            self.add_flow(dp, match, actions, priority, cookie)

        # Reset log formatter
        self.set_default_log_formatter()
Пример #28
0
Файл: nat.py Проект: wil/pyroman
class Nat:
	"""
	Represents a Network Address Translation rule.
	"""
	def __init__(self, client, server, ip, port, dport, dir, loginfo):
		"""
		Create a new NAT rule

		client -- clients allowed to access this NAT rule
		server -- host nick the NAT is applied to
		ip -- IP that is used in NAT
		port -- Ports that are used in NAT
		dport -- Destination port for single port redirections
		dir -- incoming, outgoing or bidirecitonal NAT

		Note that the NAT is always applied to the "server" host, the UI
		accessible function is responsible to eventually exchange client
		and server for "outgoing" NATs (where the naming of client, server
		makes more sense the other way, think of workstations accessing
		web server via a NAT)
		"""
		if server == "":
			raise PyromanException("Nat lacking a server host (client: %s, server: %s, ip: %s) at %s" % (client, server, ip, loginfo))
		if ip == "":
			raise PyromanException("Nat lacking IP address: (client: %s, server: %s) at %s" % (client, server, loginfo))
		if dir not in ["in", "out", "both"]:
			raise PyromanException("Nat with invalid direction: (client: %s, server: %s, ip: %s, dir: %s) at %s" % (client, server, ip, dir, loginfo))
		if not Util.verify_ip4(ip):
			raise PyromanException("Nat with invalid IP address: (client: %s, server: %s, ip: %s) at %s" % (client, server, ip, loginfo))
		if port:
			try:
				self.port = Port(port)
			except PortInvalidSpec:
				raise PyromanException("Nat port specification invalid: (client: %s, server: %s, ip: %s, port: %s) at %s " % (client, server, ip, port, loginfo))
			if not self.port.forIPv4():
				raise PyromanException("Non-IPv4 port specified: "+port)
		else:
			self.port = None
		if dport:
			try:
				self.dport = Port(dport)
			except PortInvalidSpec:
				raise PyromanException("Nat dport specification invalid: (client: %s, server: %s, ip: %s, port: %s, dport: %s) at %s " % (client, server, ip, port, dport, loginfo))
			if not self.dport.forIPv4():
				raise PyromanException("Non-IPv4 port specified: "+dport)
		else:
			self.dport = None
		if self.dport and not (self.port.proto == self.dport.proto):
			raise PyromanException("Nat ports have different protocols: (client: %s, server: %s, ip: %s, port: %s, dport: %s) at %s" % (client, server, ip, port, dport, loginfo))
		if dport and not port:
			raise PyromanException("Nat with destination port, but no source port: (client: %s, server: %s, ip: %s, dport: %s) at %s" % (client, server, ip, dport, loginfo))
		self.client = Util.splitter.split(client)
		self.server = Util.splitter.split(server)
		self.ip = ip
		# port, dport are set above
		self.dir = dir
		self.loginfo = loginfo

	def gen_snat(self, client, server):
		"""
		Internal helper function, with client, server objects
		"""
		iff = client.iface.get_filter("d")
		target = "SNAT --to-source %s" % self.ip
		# do we have a port restriction?
		pfilter = ""
		if self.port and self.dport:
			pfilter = self.dport.get_filter_proto() + " " + self.dport.get_filter_port("s")
			target = target + ":%s" % self.port.port
		elif self.port:
			pfilter = self.port.get_filter_proto() + " " + self.port.get_filter_port("s")

		c = Firewall.chains["natPOST"]
		for sip in server.ip:
			filter = iff[0] + " -s %s" % sip
			c.append4("%s %s -j %s" % (filter, pfilter, target), self.loginfo)

	def gen_dnat(self, client, server):
		"""
		Internal helper function, with client, server objects
		"""
		iff = client.iface.get_filter("s")
		filter = iff[0] + " -d %s" % self.ip
		# do we have a port restriction?
		pfilter = ""
		if self.port:
			pfilter = self.port.get_filter_proto() + " " + self.port.get_filter_port("d")

		c = Firewall.chains["natPRE"]
		for sip in server.ip:
			target = "DNAT --to-destination %s" % sip
			if self.dport:
				target = target + ":%s" % self.dport.port
			c.append4("%s %s -j %s" % (filter, pfilter, target), self.loginfo)

	def generate(self):
		for c in self.client:
			for s in self.server:
				client = Firewall.hosts[c]
				server = Firewall.hosts[s]
				# sanity checks, that should be moved to "verify"
				if not client or not server:
					raise PyromanException("Client or server not found for NAT defined at %s" % self.loginfo)
				if client.iface == server.iface:
					raise PyromanException("client interface and server interface match (i.e. cannot NAT!) for NAT defined at %s" % self.loginfo)

				if self.dir in ["in", "both"]:
					self.gen_dnat(client, server)
				if self.dir in ["out", "both"]:
					self.gen_snat(client, server)
Пример #29
0
                    totalProfits[0] += profit
                elif self.containerInfo[containerID][2] == "Metro":
                    totalProfits[1] += profit
                # if containerID in self.promoted2updatedPrice:
                movesDetails.append(f"Deliver container {containerID} from coordinate ({x+1}, {y+1}, {z+1}) with updated price {contractPrice}")
                # else:
                #     movesDetails.append(f"Deliver container {containerID} from coordinate ({x+1}, {y+1}, {z+1})")
                amount2deliver -= 1
                z -= 1
        with open("Final report.txt", 'w') as f:
            for line in movesDetails:
                f.write(line+"\n")
        with open("Final report performance.txt", 'w') as f:
            f.write(f"Total contract prices = {totalContractPrice}\n")
            f.write(f"Carrefour profits = {totalProfits[0]}\n")
            f.write(f"Metro profits = {totalProfits[1]}\n")
            f.write(f"Port Throughput = {totalDelivered}\n")
        print(totalContractPrice, totalProfits, totalDelivered)


if __name__ == "__main__":
    carrefour = Customer("carrefour_report.csv", "container.csv",
                         name="carrefour")
    metro = Customer("metro_report.csv", "container.csv", name='metro')
    port = Port("container.csv")
    moop = Moop(port,
                [carrefour, metro],
                ["carrefour_output.csv", "metro_output.csv"])

    moop.optimize()
Пример #30
0
car2 = Car('辽B12345', '黄色', '745', '宝马')
car3 = Car('辽C12345', '蓝色', 'GLC', '奔驰')
car4 = Car('辽D12345', '黑色', 'DSG', '迈腾')
car5 = Car('辽E12345', '白色', 'CS35', '长安')

car_list = [car1, car2, car3, car4, car5]

owner1 = CarOwner('1', 'Uzi', '13845789865', car1)
owner2 = CarOwner('2', 'Letme', '14578956858', car2)
owner3 = CarOwner('3', 'Xiaohu', '15858585858', car3)
owner4 = CarOwner('4', 'Mlxg', '16688666688', car4)
owner5 = CarOwner('5', 'Ming', '17985465258', car5)

owner_list = [owner1, owner2, owner3, owner4, owner5]

port1 = Port('5', 5, '0')
port2 = Port('15', 5, '0')
port3 = Port('25', 5, '0')

port_list = [port1, port2, port3]

park1 = Park('浑南停车场', 100, '浑南', 100)
park2 = Park('大东停车场', 100, '大东', 100)
park3 = Park('沈河停车场', 100, '沈河', 100)

park_list = [park1, park2, park3]
'''随机一次场景的各项属性'''
this_owner = random.sample(owner_list, 1)  #随机一个车主
this_park = random.sample(park_list, 1)  #随机一个停车场
this_port = random.sample(port_list, 1)  #随机一个车位
Пример #31
0
        print(f"Host {self.ip}")
        print(f"OS fingerprint: {self.os} - {self.version}")
        if not len(self.ports):
            print(f"Ports: none")
            return
        print(f"Ports: ")
        for p in self.ports.values():
            p.print()


if __name__ == "__main__":
    print(f"### device.py example ###\n")

    d = Device("127.0.0.1", "Windows 10", "Build 1901")

    p = Port(25, "tcp")
    p.service = "smtp"
    p.software = "postfix"
    p.version = "2.13"
    v = Vulnerability()
    v.software = p.software
    v.version = p.version
    v.type = "RCE"
    v.description = "sample RCE desc"
    v.addExploit("https://cve.truc/exp1")
    v.addExploit("https://cve.truc/exp2")
    p.addVuln(v)

    d.addPort(p)

    d.print()
Пример #32
0
	def __init__(self, addr):
		sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
		sock.connect(addr)
		self.port = Port(sock)
Пример #33
0
    def add_port(self, k, v={}):
        # add port specific vlans or fall back to defaults
        v = copy.copy(v) if v else {}

        if 'exclude' in self.config_default:
            excluded = self.is_excluded(self.config_default['exclude'], k)
        else:
            excluded = False

        # set default vlans if we have any
        if not excluded and 'vlans' in self.config_default:
            v.setdefault('vlans', self.config_default['vlans'])
        else:
            v.setdefault('vlans', [])

        # set default type
        if not excluded and 'type' in self.config_default:
            v.setdefault('type', self.config_default['type'])
        else:
            v.setdefault('type', self.default_type)

        # set default acls
        if not excluded and 'acls' in self.config_default:
            v.setdefault('acls', self.config_default['acls'])
        else:
            v.setdefault('acls', [])

        # add vlans & acls configured on a port
        for vid in v['vlans']:
            if vid not in self.vlans:
                self.vlans[vid] = VLAN(vid)
            if k not in self.ports:
                self.ports[k] = Port(k, v['type'], v['acls'])
            self.vlans[vid].add_port(self.ports[k])

        # add configuration that should be on all ports
        for c in self.config_all:
            c.setdefault('vlans', [])
            c.setdefault('type', v['type'])
            c.setdefault('exclude', [])
            c.setdefault('acls', [])

            # exclude ports
            if self.is_excluded(c['exclude'], k):
                continue

            # add port to 'all' vlans
            for vid in c['vlans']:
                if k not in self.ports:
                    self.ports[k] = Port(k, c['type'], v['acls'])
                port = self.ports[k]

                if vid in self.vlans and port in self.vlans[vid].get_ports():
                    # port is already in vlan, skip
                    continue

                if vid not in self.vlans:
                    self.vlans[vid] = VLAN(vid)
                self.vlans[vid].add_port(port)

            # add 'all' acls to port
            for acl in c['acls']:
                self.ports[k].add_acl(acl)
Пример #34
0
	def createContainer(self):
		port=Port()
		newPort=port.getNewPort()
		sp.getoutput("sudo docker run -dit -p {}:3333  xpra_vlc:v4".format(newPort))
		return newPort
Пример #35
0
def process_optional_input(pop = None, conc = None, port_y = None):
	global port_name, port_ambient_conc, port_y0, port_c0, port_pop_struc, port_pop, base_conc, port_real_em, ratio
	if pop is not None:
		port_pop = pop
	if conc is not None:
		port_ambient_conc = conc
	# call Port class to do calc, if use inputs his own y, then pass y to port class instead of y0 to calc ymin
	if port_y is None:
		port = Port(port_name, port_ambient_conc, port_y0, port_c0, port_pop_struc, port_pop, base_conc, port_real_em, ratio)
		indicator = 0
	else:
		port = Port(port_name, port_ambient_conc, port_y, port_c0, port_pop_struc, port_pop, base_conc, port_real_em, ratio)
		indicator = 1
	name_t = port_name
	ambient_t = port_ambient_conc
	y0_t = port_y0
	c0_t = port_c0
	pop_struc_t = port_pop_struc
	pop_t = port_pop
	base_t = base_conc
	em_t = port_real_em
	#print impact.key
	impact = port.get_impact(indicator)
	
	# process/aggregate the impact in some way
	result_disease_age = {}
	result_disease_time = {}
	result_disease_zone = {}
	result_disease_age_yll = {}
	for key in impact.keys():
		if key != 'ARI':
			impact_all_age = np.empty(age_group)
			for i in range(age_group):
				impact_all_age[i] = sum(impact[key][i][4, :])
			result_disease_age[key] = np.around(impact_all_age, 2)
		else:
			result_disease_age[key] = np.around(np.array([sum(impact[key][0][4, :])]),2)
	# does not matter if ARI or not
	for key in impact.keys():
		impact_sum_age = sum(impact[key])
		result_disease_zone[key] = np.around(impact_sum_age[4, :],2)
		#print impact_sum_age.key
		temp = np.empty(time_interval)
		for i in range(time_interval):
			temp[i] = sum(impact_sum_age[i, :])
		result_disease_time[key] = np.around(temp, 2)
		#sum_age_t = impact_sum_age
		#print sum_age_t.key
	for key in impact.keys():
		if key != "ARI":
			result_disease_age_yll[key] = np.around(np.array(life_exp) * result_disease_age[key], 2)
			#-- add total col for yll except its ARI
			result_disease_age_yll[key] = np.append(result_disease_age_yll[key], sum(result_disease_age_yll[key]))
			#-- add total col for age except its ARI
			result_disease_age[key] = np.append(result_disease_age[key], sum(result_disease_age[key]))
		else:
			result_disease_age_yll[key] = np.around(np.array(life_exp[0]) * result_disease_age[key], 2)
	#exp_t = life_exp
	#age_t = result_disease_age_yll["ARI"]
	#print exp_t.key
	#--- Add N/A and total in cols for ARI
	result_disease_age['ARI'] = np.append(result_disease_age['ARI'], np.array([ 0 for i in range(age_group - 1)]))
	result_disease_age['ARI'] = np.append(result_disease_age['ARI'], result_disease_age['ARI'][0])
	result_disease_age_yll['ARI'] = np.append(result_disease_age_yll['ARI'], np.array([ 0 for i in range(age_group - 1)]))
	result_disease_age_yll['ARI'] = np.append(result_disease_age_yll['ARI'], result_disease_age_yll['ARI'][0])
	#-- add total row below each table
	#result_disease_age['Total'] = np.zeros(age_group + 1)
	#result_disease_time['Total'] = np.zeros(age_group + 1)
	#result_disease_age_yll['Total'] = np.zeros(age_group + 1)
	#result_disease_zone['Total'] = np.zeros(age_group + 1)
	#for i in range(age_group + 1):
	#	for key in result_disease_age.keys():
	#		if key!= 'Total' and result_disease_age[key][i] != 'N/A':
	#			result_disease_age['Total'][i] = result_disease_age['Total'][i] + float(result_disease_age[key][i])
	#-- get rid of 0-4 value for age time before adding up cols
	#result_disease_age['LC'][0] = 0
	#result_disease_age['CP'][0] = 0
	#result_disease_age_yll['LC'][0] = 0
	#result_disease_age_yll['CP'][0] = 0
	#-- add total row below table
	add_total(result_disease_age)
	add_total(result_disease_time, time_interval)
	add_total(result_disease_age_yll)
	add_total(result_disease_zone, len(result_disease_zone['ARI']))
	return {'age': result_disease_age, 'time': result_disease_time, 'zone': result_disease_zone, 'yll': result_disease_age_yll, 'indicator': indicator}
Пример #36
0
class TcpTunnel(ImmortalThread):
    def __init__(self, vcp):
        #super(TcpTunnel, self).__init__(self)
        ImmortalThread.__init__(self)
        self._needs_reconfig = 0
        # link to the port object
        self._vcp = vcp
        self._lock = Lock()
        self._op_lock = Lock()
        # list of operations to apply to an {out|in}bound tcp 
        # segment. In the future this might include operations 
        # such as encryption or compression - for now, only the
        # header info. that is applied by devices such as 
        # Lantronix's UDS-10 is supported.  Up refers to what is
        # being applied to outbound tcp data, down to received.
        # Methods should be added to these lists in the order they
        # are to be applied.
        self._up_segment_ops = []
        self._down_segment_ops = []
        # transaction identifier - used only in vcp mode.
        self.__tid = 0
        self._pending_tid = 0
        # one and only poll object.  socket, serial fd and
        # command pipe are all polled.
        self._poll_obj = None
        # command pipe allows other threads to insert control
        # messages.
        self._cmd_pipe = None
        # both sides (serial & socket) of the tunnel
        self._sock_listen_fd = None
        self._sock_fd = None
        self._serial_port = None
        # tcp state management
        self._is_connected = 0
        self.is_active = 0
        # tunnel statistics
        self.tcp_bytes_rcvd = 0
        self.tcp_bytes_sent = 0
        self.serial_bytes_rcvd = 0
        self.serial_bytes_sent = 0
        self.connection_attempts = 0
            
    def configure(self, config):
        self.tty = '/dev/tty' + config['dev'][-2:]
        self.tcp_port = int(config['tcp_port'])
        self.mode = config['mode']
        self.timeout_msec = config['p_timeout_msec']

        if self.mode == 'vcp':
            if self._up_segment_ops.count(self._add_vcp_header) == 0:
                self._up_segment_ops.append(self._add_vcp_header)
            if self._down_segment_ops.count(self._remove_vcp_header) == 0:
                self._down_segment_ops.append(self._remove_vcp_header)
        self.is_server = int(config['is_server'])
        if self.is_server == 0:
            self.host = config['host']  # who we're connecting to.
        if self.is_active:
            # tunnel is being reconfigured "in flight".
            self._needs_reconfig = 1
            self._send_cmd('reconfig')
            if self._is_in_accept():
                self._clear_accept()
                    
    def run(self):
        self._needs_reconfig = 0
        if self.is_active:
            # we've restarted due to a configuration change
            self.start_tunnel()
        else:
            if not self._cmd_pipe:
                # set up the command pipe and begin to build the poll obj.
                self._cmd_pipe = os.pipe()
                self._poll_obj = select.poll()
                self._poll_obj.register(self._cmd_pipe[READ],
                    select.POLLIN | select.POLLERR | select.POLLHUP)
        while 1:
            # no poll timeout, wait here until kicked to start.
            evt = self._poll_obj.poll(-1)
            if evt[0][0] == self._cmd_pipe[READ]:
                if evt[0][1] == select.POLLIN:
                    cmd = os.read(self._cmd_pipe[READ], 32)
                    if cmd.find('start') >= 0:
                        self.start_tunnel()
            # cmd pipe poll err, critical, hard restart
            self._cmd_pipe = None
            self._poll_obj = None
            raise ERestart()
                        
    def start_tunnel(self):
        if self is not currentThread():
            self._send_cmd('start')
            return
        self._op_lock.acquire()
        try:
            self.is_active = 1
            # set up Port object for the tunnel that reads\writes to the 
            # slave device file of the pseudo-terminal pair. 
            if not self._serial_port:
                self._serial_port = Port()
            cfg = self._vcp.configuration()
            cfg['dev'] = self.tty
            cfg['name'] = '_slave'
            cfg['parent'] = self._vcp
            self._serial_port.configure(cfg)
            self._op_lock.release()
        except:
            self._op_lock.release()
        while self.is_active:
            if not self._serial_port.is_open():
                self._serial_port.open()
                self._serial_port.drain()
            try:
                if self.is_server:
                    self._do_listen()
                else:
                    self._do_connect()
            except:
                msglog.exception()
                if self._serial_port and not self._serial_port.is_open():
                    self._serial_port.close()

    def stop_tunnel(self):
        self.is_active = 0
        if self is not currentThread():
            self._send_cmd('stop')
            if self._is_in_accept():
                self._clear_accept()
        else:
            self._op_lock.acquire()
            try:
                self._tear_down_fds()
            finally:
                self._op_lock.release()
            #raise ERestart()
        
    def is_connected(self):
        self._op_lock.acquire()
        result = self._is_connected
        self._op_lock.release()
        return result
                                
    def _create_socket(self):
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        return s
            
    def _close_socket(self):
        self._is_connected = 0
        self._sock_fd.close()
            
    def _send_cmd(self, cmd):
        self._lock.acquire()
        try:
            os.write(self._cmd_pipe[WRITE], cmd)
        finally:
            self._lock.release()
            
    def _do_connect(self):
        while self.is_active:
            self._sock_fd = self._create_socket()
            while not self._is_connected:
                self.connection_attempts += 1
                try:
                    self._sock_fd.connect((self.host, self.tcp_port))
                    self._is_connected = 1
                except socket.gaierror, e:
                    # host related error, ie. hostname not resolving - possibly transient
                    self.connection_attempts += 1
                    msglog.log('VCP', WARN, 'Error resolving hostname %s.' % self.host)
                    time.sleep(60)
                    raise EConnectionError
                except socket.error, e:
                    # connection error, possibly transient - sleep for a bit and retry
                    self.connection_attempts += 1
                    time.sleep(30) 
            if self._needs_reconfig:
                self._is_connected = 0
                self._tear_down_fds()
                raise ERestart()
            # loop in _do_tunnel until the tcp connection or the framework 
            # based consumer (ie. protocol) "goes away".
            self._do_tunnel()
            self._is_connected = 0
Пример #37
0
	def __init__(self, host):
		sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
		sock.connect((host, SERVICE_PORT))
		self.port = Port(sock)
Пример #38
0
 def createSplunkContainer(self):
     port = Port()
     newPort = port.getNewPort()
     sp.getoutput(
         "sudo docker run -dit -p {}:8000  splunk:v4 spl".format(newPort))
     return newPort
Пример #39
0
 def create_port_list(self, start_port):
     port = Port()
     port_list = port.create_port_list(start_port, self.devices_list)
     return port_list
Пример #40
0
 def __init__(self):
     super().__init__()
     self.port = Port()
     # draw UI
     self.initUI()
Пример #41
0
    def add_port(self, name, is_output=False, flags=0, ptr=None):
        port = Port(self, self.scene())
        port.set_is_output(is_output)
        port.set_name(name)
        port.set_node(node=self)
        port.set_port_flags(flags)
        port.set_ptr(ptr)

        self._ports.append(port)
Пример #42
0
class MainAPP(QWidget):
    def __init__(self):
        super().__init__()
        self.port = Port()
        # draw UI
        self.initUI()

    def initUI(self):
        # size and location
        # self.setGeometry(500, 500, 500, 500)
        self.resize(500, 400)
        self.center()

        self.setWindowTitle("UART")

        self.setWindowIcon(QIcon("./icon/title.ico"))

        self.button()

        self.show()

    def center(self):
        window = self.frameGeometry()
        # 获取中心点
        centerPoint = QDesktopWidget().availableGeometry().center()
        window.moveCenter(centerPoint)
        # self.move(window.topLeft())

    def button(self):
        self.spectrum = QPushButton("Spectrum")
        self.spectrum.clicked.connect(self.spectrumAction)
        # self.spectrum.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)

        self.colorMap = QPushButton("ColorMap")
        self.colorMap.clicked.connect(self.colorMapAction)
        # self.colorMap.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)

        self.adc = QPushButton("ADC")
        self.adc.clicked.connect(self.adcAction)

        self.statusBox = QLabel()
        self.statusBox.setText(self.statusText())
        self.statusBox.setAlignment(QtCore.Qt.AlignCenter)

        self.connection = QPushButton('连接串口')
        self.connection.clicked.connect(self.connect)

        self.setting = QPushButton('串口设置')
        self.setting.clicked.connect(self.settingAction)

        vbox = QVBoxLayout()
        vbox.addWidget(self.adc)

        vbox.addWidget(self.spectrum)

        vbox.addWidget(self.colorMap)
        hbox = QHBoxLayout()
        # hbox.addStretch(1)
        hbox.addLayout(vbox)

        vbox2 = QVBoxLayout()
        vbox2.addStretch(1)
        vbox2.addWidget(self.statusBox)
        vbox2.addStretch(1)
        vbox2.addWidget(self.connection)
        vbox2.addWidget(self.setting)
        vbox2.addStretch(1)
        hbox.addLayout(vbox2)
        # hbox.addStretch(1)
        self.setLayout(hbox)

    def statusText(self):
        status = '当前配置\n波特率 ' + \
            str(self.port.bandradte) + '\n停止位 1\nADC数据接收类型 uint8\nADC采样精度 8bit'
        return status

    def spectrumAction(self):
        if self.spectrum.isEnabled():
            # print("yes")
            self.port.spectrum_one_figure()
            # self.spectrum.setEnabled(False)

    def colorMapAction(self):
        if self.spectrum.isEnabled():
            self.port.colormap()

    def adcAction(self):
        self.ADC_Window = adcWindow(self.port)
        self.ADC_Window.show()
        # QtWidgets.QFileDialog.getExistingDirectory(self, "@2", "./")

    def connect(self):
        if (self.port.ser is None or self.port.ser.isOpen() is False):
            self.port.openPort()
        if (self.port.ser.isOpen()):
            QMessageBox.information(self, '提示', '连接成功', QMessageBox.Ok)

    def settingAction(self):
        # QMessageBox.information(self, '提示', '正在建设', QMessageBox.Ok)
        self.settings = Settings(self.port)
        self.settings.show()

    @staticmethod
    def refresh():
        QApplication.processEvents()
Пример #43
0
 def _finish_init_(self):
     for p in self._obj.ports:
         self._children.append(Port(p, self, self._outbox))
Пример #44
0
            cv2.putText(frame, s, (width+30,50), cv2.FONT_HERSHEY_PLAIN, 1, BLACK, 2)


    cv2.imshow("output", frame)


def getMiddle(x, y):
    return ((x[0] + y[0]) / 2, (x[1] + y[1]) / 2)

mx = []
my = []

if __name__ == '__main__':
    cv2.namedWindow('output')
    cv2.setMouseCallback('output', clickHandler)
    port = Port()
    port.init()

    lasttimeSent = None

    prevRobot = [None] * N
    prevWhite = [None] * N

    vc = cv2.VideoCapture(1)
    balls = None
    rval, frame = vc.read()

    while rval:
        rval, frame = vc.read()
        robots = [None] * N
        whites = [None] * N