模型加载完成时执行动作

True

无标题 (3)

重写_register_hook, 所有的模型加载完成之后会执行这个函数, 在这里执行确保所有模型都是可以访问的状态。

    @api.model_cr
    def _register_hook(self):
        """ stuff to do right after the registry is built """
        global msg_client
        msg_client = TransitThread(self.env)
        msg_client.start()

xxxxxxxxxx
 
    @api.model_cr
    def _register_hook(self):
        """ stuff to do right after the registry is built """
        global msg_client
        msg_client = TransitThread(self.env)
        msg_client.start()
已复制

# -*- coding: utf-8 -*-

import socket
import threading
import select
import collections
import time
from odoo import models, api


class Singleton(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, '_inst'):
            cls._inst = super(Singleton, cls).__new__(cls)
        return cls._inst


class TransitClient:
    write_list = collections.deque()
    cache_recv_msg = ''
    running = False
    read_callback = None

    def __init__(self, server_addr):
        self.server_addr = server_addr
        self.msg_socket = None
        self.cache_recv_msg = ""

    def do_connect(self):
        try:
            self.msg_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.msg_socket.connect(self.server_addr)
            self.msg_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            self.msg_socket.setblocking(0)
            self.running = True
        except socket.error as identifier:
            print(time.ctime(), "connect to", self.server_addr, "error: ", identifier)
            print("try reconnect...")
            raise identifier

    def do_close(self):
        self.msg_socket.close()
        self.cache_recv_msg = ''

    def set_read_callback(self, callback):
        self.read_callback = callback

    def write(self, msg):
        self.write_list.append(msg)

    def do_write(self):
        try:
            send_data = bytes(self.format_msg(self.write_list[0]), 'utf-8')
            self.msg_socket.send(send_data)
            self.write_list.popleft()
            return True
        except socket.error as identifier:
            print(time.ctime(), "send to", self.server_addr, "error: ", identifier)
            return False

    def do_read(self):
        try:
            data = self.msg_socket.recv(4096)
            self.cache_recv_msg += data.decode('utf-8')
            self.parse_data()
            return True
        except socket.error as identifier:
            print(time.ctime(), "recv from", self.server_addr, "error: ", identifier)
            return False

    @staticmethod
    def format_msg(msg):
        return '%d|%s' % (len(msg), msg)

    def parse_data(self):
        pos = self.cache_recv_msg.find('|')
        if pos == -1:
            return
        size = int(self.cache_recv_msg[: self.cache_recv_msg.find('|')])
        need_size = size + pos + 1
        if need_size <= len(self.cache_recv_msg):
            content = self.cache_recv_msg[pos + 1: size + pos + 1]
            if self.read_callback:
                self.read_callback(content)
            else:
                print('recved data:', content)
            self.cache_recv_msg = self.cache_recv_msg[need_size:]
            if need_size != len(self.cache_recv_msg):
                self.parse_data()

    def run(self):
        while True:
            if self.running:
                sock_read, sock_write, sock_error = select.select([self.msg_socket], [self.msg_socket], [self.msg_socket])
                ret = True
                # self.write('22222')
                if sock_write and self.write_list:
                    ret = self.do_write()
                if sock_read:
                    ret = self.do_read()
                if sock_error or not ret:
                    self.running = False
                time.sleep(0.01)
            else:
                print("try reconnect...")
                self.do_close()
                self.do_connect()


class TransitThread(threading.Thread):

    def __init__(self, *args, **kwargs):
        # 这里会调用父类的所有有初始化方法
        super(TransitThread, self).__init__(args=args, kwargs=kwargs)
        self.env = args[0]
        self.host = '172.16.109.15'
        self.port = 54327
        self.client = TransitClient((self.host, self.port))
        self.client.set_read_callback(self.read_callback)

    def run(self):
        self.client.do_connect()
        self.client.run()

    def send_message(self, msg):
        '''
        写入消息
        :param msg:
        :return:
        '''
        self.client.write(msg)

    def read_callback(self, msg):
        '''
        读取消息回调
        :param msg:
        :return:
        '''
        print('recved data:', msg)


msg_client = None
ats_client = None
interlock_client = None


class MsgClientModel(models.Model):
    _name = 'metro_park_dispatch.msg_client'
    _description = '消息收发客户端'

    @api.model_cr
    def _register_hook(self):
        """ stuff to do right after the registry is built """
        global msg_client
        msg_client = TransitThread(self.env)
        msg_client.start()

    @api.model
    def send_msg(self, msg):
        '''
        发送通知消息
        :return:
        '''
        msg_client.send_message(msg)

xxxxxxxxxx
 
# -*- coding: utf-8 -*-
​
import socket
import threading
import select
import collections
import time
from odoo import models, api
​
​
class Singleton(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, '_inst'):
            cls._inst = super(Singleton, cls).__new__(cls)
        return cls._inst
​
​
class TransitClient:
    write_list = collections.deque()
    cache_recv_msg = ''
    running = False
    read_callback = None
​
    def __init__(self, server_addr):
        self.server_addr = server_addr
        self.msg_socket = None
        self.cache_recv_msg = ""
​
    def do_connect(self):
        try:
            self.msg_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.msg_socket.connect(self.server_addr)
            self.msg_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            self.msg_socket.setblocking(0)
            self.running = True
        except socket.error as identifier:
            print(time.ctime(), "connect to", self.server_addr, "error: ", identifier)
            print("try reconnect...")
            raise identifier
​
    def do_close(self):
        self.msg_socket.close()
        self.cache_recv_msg = ''
​
    def set_read_callback(self, callback):
        self.read_callback = callback
​
    def write(self, msg):
        self.write_list.append(msg)
​
    def do_write(self):
        try:
            send_data = bytes(self.format_msg(self.write_list[0]), 'utf-8')
            self.msg_socket.send(send_data)
            self.write_list.popleft()
            return True
        except socket.error as identifier:
            print(time.ctime(), "send to", self.server_addr, "error: ", identifier)
            return False
​
    def do_read(self):
        try:
            data = self.msg_socket.recv(4096)
            self.cache_recv_msg += data.decode('utf-8')
            self.parse_data()
            return True
        except socket.error as identifier:
            print(time.ctime(), "recv from", self.server_addr, "error: ", identifier)
            return False
​
    @staticmethod
    def format_msg(msg):
        return '%d|%s' % (len(msg), msg)
​
    def parse_data(self):
        pos = self.cache_recv_msg.find('|')
        if pos == -1:
            return
        size = int(self.cache_recv_msg[: self.cache_recv_msg.find('|')])
        need_size = size + pos + 1
        if need_size <= len(self.cache_recv_msg):
            content = self.cache_recv_msg[pos + 1: size + pos + 1]
            if self.read_callback:
                self.read_callback(content)
            else:
                print('recved data:', content)
            self.cache_recv_msg = self.cache_recv_msg[need_size:]
            if need_size != len(self.cache_recv_msg):
                self.parse_data()
​
    def run(self):
        while True:
            if self.running:
                sock_read, sock_write, sock_error = select.select([self.msg_socket], [self.msg_socket], [self.msg_socket])
                ret = True
                # self.write('22222')
                if sock_write and self.write_list:
                    ret = self.do_write()
                if sock_read:
                    ret = self.do_read()
                if sock_error or not ret:
                    self.running = False
                time.sleep(0.01)
            else:
                print("try reconnect...")
                self.do_close()
                self.do_connect()
​
​
class TransitThread(threading.Thread):
​
    def __init__(self, *args, **kwargs):
        # 这里会调用父类的所有有初始化方法
        super(TransitThread, self).__init__(args=args, kwargs=kwargs)
        self.env = args[0]
        self.host = '172.16.109.15'
        self.port = 54327
        self.client = TransitClient((self.host, self.port))
        self.client.set_read_callback(self.read_callback)
​
    def run(self):
        self.client.do_connect()
        self.client.run()
​
    def send_message(self, msg):
        '''
        写入消息
        :param msg:
        :return:
        '''
        self.client.write(msg)
​
    def read_callback(self, msg):
        '''
        读取消息回调
        :param msg:
        :return:
        '''
        print('recved data:', msg)
​
​
msg_client = None
ats_client = None
interlock_client = None
​
​
class MsgClientModel(models.Model):
    _name = 'metro_park_dispatch.msg_client'
    _description = '消息收发客户端'
​
    @api.model_cr
    def _register_hook(self):
        """ stuff to do right after the registry is built """
        global msg_client
        msg_client = TransitThread(self.env)
        msg_client.start()
​
    @api.model
    def send_msg(self, msg):
        '''
        发送通知消息
        :return:
        '''
        msg_client.send_message(msg)
​
​
​
已复制

in Funenc Odoo Team

# odoo汇总

禁止tree 点击弹出

True