Python system.system函数代码示例

 def restart(self):
     yield self._lock.acquire()
     try:
         yield system.system('ifconfig', self.iface, '0.0.0.0')
         yield system.system('ifconfig', self.iface, 'down')
     finally:
         self._lock.release()

    def _locked_cb(self, old_state, new_state):
        if self._iface_status_pub.get() >= IFSTATE.PLUGGED:
            yield system.system('ip', 'route', 'flush', 'table', self.table, 'dev', self.iface)

        if new_state:
            gateway = new_state['gateway']
            ip = new_state['ip']
            network_slashed = new_state['network_slashed']
            yield system.system('ip', 'route', 'add', 'table', self.table, 'default', 'dev', self.iface, 'via', gateway, 'src', ip, 'onlink')
            yield system.system('ip', 'route', 'add', 'table', self.table, network_slashed, 'dev', self.iface, 'src', ip)

    def __init__(self):
        self.interfaces = {}
        self.update_event = event.Event()
        self.update_interval = 1
        self.radio_manager = radio_manager.RadioManager()
        self.inactive_penalty = config.get_parameter('inactive_penalty', 50)
        self.forced_interface = ""
        self.tunnel_interface = config.get_parameter('tunnel_interface', "")
        self.use_tunnel = True
        self.active_interfaces = []

        self.basestation = config.get_parameter('base_station')
#        print "Resolving basestation IP. (Blocking operation.)"
#        self.basestation_ip = socket.gethostbyname(config.get_parameter('base_station'))

        # Add rules to guarantee that local routes go to the main table.
#        self.local_net_rule = ip_rule.IpRule(RULEID.LOCAL)
#        for subnet in config.get_parameter('local_networks'):
#            self.local_net_rule.add('to', subnet, 'lookup', 'main')

        self.local_net_rules = []
        for (i, subnet) in enumerate(config.get_parameter('local_networks')):
            self.local_net_rules.append(ip_rule.IpRule(RULEID.LOCAL+i))
            self.local_net_rules[i].add('to', subnet, 'lookup', 'main')

        # Add a rule to send through the vpn.
        if self.tunnel_interface:
            self.vpn_rule = ip_rule.IpRule(RULEID.DEFAULT)
            # Use LINK here because netlink_monitor's parsing rules don't
            # currently work on vpn interfaces.
            system.system('ip', 'route', 'flush', 'table', str(RULEID.DEFAULT))
            netlink_monitor.get_state_publisher(self.tunnel_interface,
                    IFSTATE.LINK).subscribe(self._refresh_default_route)


        # Create all the interfaces.
        interface_names = config.get_parameter('interfaces').keys()
        ifaceid = RULEID.FIRST_IFACE
        for iface in interface_names:
            try:
                new_iface = self.interfaces[iface] = interface.construct(iface, ifaceid)
                new_iface.score = InterfaceSelector.TERRIBLE_INTERFACE 
                new_iface.prescore = InterfaceSelector.TERRIBLE_INTERFACE
                ifaceid += 1
            except interface.NoType:
                print >> sys.stderr, "Interface %s has no type."%iface
                sys.exit(1)
            except interface.UnknownType, e:
                print >> sys.stderr, "Interface %s has unknown type %s."%(iface, e)
                sys.exit(1)
            except:

def UpdateDB(corp, victims) :
    chars = corp.chars
    systems = corp.systems

    NewNotifs = []
    for name, char in chars.items() :
        print("Loading data for " + name + "...")
        NewNotifs += char.GetNotifications()
        #NewNotifs = NewNotifs + char.GetNotifications()

    ProcessKills(NewNotifs, victims)

    for n in NewNotifs :
        if n.system not in corp.systems :
            corp.systems[n.system] = system.system(n.system, corp.ID)

        if n.type == 'plex' :
            n.char.addPlex(n)
            corp.addPlex(n)
            corp.systems[n.system].addPlex(n)
        if n.type == 'kill' :
            corp.systems[n.system].addKill(n)
            n.char.addKill(n)
            corp.addKill(n)

    for i in [chars, systems] :
        for k, v in i.items() :
            v.save()
    corp.save()

def main():
    app = system.system()
    app.setup()

    #app.switch_mode(mode.play.play())
    app.switch_mode(mode.menu.menu())
    app.run()

def eddieguts(Config, eddieHistory):

    # instantiate a process list
    log.log( "<eddie>eddieguts(), creating process object", 8 )
    directive.plist = proc.procList()

    # instantiate a disk usage list
    log.log( "<eddie>eddieguts(), creating df object", 8 )
    directive.dlist = df.dfList()

    # instantiate a netstat list
    log.log( "<eddie>eddieguts(), creating netstat object", 8 )
    directive.nlist = netstat.netstat()

    # instantiate a system object
    log.log( "<eddie>eddieguts(), creating system object", 8 )
    directive.system = system.system()

    if module_iostat:
        # instantiate an iostat object
        log.log( "<eddie>eddieguts(), creating iostat object", 8 )
        directive.iostat = iostat.iostat()

    # Now do all the checking
    log.log( "<eddie>eddieguts(), beginning checks", 7 )
    check(Config)

    # Save history (debug.. FS only for now...)
    eddieHistory.save('FS',directive.dlist)

 def GET(self):
     import system
     data = system.system().GetConcifInfo()
     data['siteCount'] = public.M('sites').count()
     data['ftpCount'] = public.M('ftps').count()
     data['databaseCount'] = public.M('databases').count()
     data['lan'] = public.getLan('index')
     return render.index(data)

 def _cb(self, old_state, new_state):
     plugged, up = new_state
     self.state = new_state
     if plugged and not up and not self._is_shutdown:
         yield self._lock.acquire()
         try:
             yield system.system('ifconfig', self.iface, 'up')
         finally:
             self._lock.release()

    def _set_or_add(self, remove_old, args):
        """Changes/adds the rule. Call with no arguments to clear the rule."""
        if self.is_shutdown:
            return
        yield self._lock.acquire()
        try:
            # Are we replacing a rule with itself?
            if remove_old and self.prev and args == self.prev:
                return
            # Add new rule
            if args:
                yield system.system('ip', 'rule', 'add', "priority", self.priority, *args)
            # Add remove old rule
            if self.prev and remove_old:
                yield system.system('ip', 'rule', 'del', "priority", self.priority, *self.prev)
            self.prev = args
            self.state_pub.set(args)

        finally:
            self._lock.release()

 def flush(self):
     self.prev = () # Won't hurt to do it here, just means we might not
                    # delete during ongoing set. Ensures it is set at
                    # end of construction.
     yield self._lock.acquire()
     try:
         retcode = None
         while not retcode:
             retcode = yield system.system(system.Quiet, 'ip', 'rule', 'del', 'priority', self.priority)
     finally:
         self._lock.release()

def LoadSystems(corpid, fpath = vars.systems) :
    systems = {}
    for fname in os.listdir(fpath + corpid + '/systems/') :
        try :
            with open(fpath + corpid + '/systems/' + fname, 'r') as file :
                js = json.load(file)
                newsys = system.system(js['name'], corpid)
                systems[js['name']] = newsys
        finally :
            pass
    return systems

def initialize():
	pl.close('all')
	global info, network, system, traces, torus, sweepingPhasespace
	reload(model)

	info = nf.info()
	network = netw.network(info=info)
	system = sys.system(info=info, network=network)
	traces = tra.traces(system, network, info=info)
	torus = tor.torus(system, network, traces, info=info)
	network.system = system
	system.traces = traces


	## customize system for web
	system.setParams(epsilon=0.3)
	system.ax.set_xlabel(r'Inactivation Variable')
	system.ax.set_ylabel(r'Voltage Variable')
	system.ax.set_title('')
	system.fig.tight_layout()
	plugins.connect(system.fig, DragPlugin(eventHandlerURL="updatesystem", radioButtonID="systemRadio"))

	# customize network
	network.ax.patch.set_facecolor('#777777')
	network.moveText(2, [0.02, -0.1])
	network.moveText(3, [0.02, -0.1])
	network.ax.texts[6].set_text('1')
	network.ax.texts[7].set_text('2')
	network.ax.texts[8].set_text('3')
	plugins.connect(network.fig, DragPlugin(eventHandlerURL="updatenetwork", radioButtonID="networkRadio"))

	# customize traces
	traces.ax.patch.set_facecolor('#777777')
	traces.fig.tight_layout()

	# customize torus
	torus.ax_traces.set_xlabel(r'phase lag: 1-2')
	torus.ax_basins.set_xlabel(r'phase lag: 1-2')
	torus.ax_traces.set_ylabel(r'phase lag: 1-3')
	torus.fig.tight_layout()
	torus.switch_processor()	# switches on the gpu if available
	if torus.USE_GPU: torus.setGridsize(24)
	plugins.connect(torus.fig, ClickPlugin(eventHandlerURL="updatetorus", radioButtonID="torusRadio"))

	# reload timing variable
	sweepingPhasespace = False;

    def GetSshInfo(self,get):
        file = '/etc/ssh/sshd_config'
        conf = public.readFile(file)
        rep = "#*Port\s+([0-9]+)\s*\n"
        port = re.search(rep,conf).groups(0)[0]
        import system
        panelsys = system.system();
        
        version = panelsys.GetSystemVersion();
        if not os.path.exists('/etc/redhat-release'):
             status = public.ExecShell("service ssh status | grep 'dead'")
        else:
            if version.find(' 7.') != -1:
                status = public.ExecShell("systemctl status sshd.service | grep 'dead'")
            else:
                status = public.ExecShell("/etc/init.d/sshd status | grep -e 'stopped' -e '已停'")
            
#       return status;
        if len(status[0]) > 3:
            status = False
        else:
            status = True
        isPing = True
        try:
            file = '/etc/sysctl.conf'
            conf = public.readFile(file)
            rep = "#*net\.ipv4\.icmp_echo_ignore_all\s*=\s*([0-9]+)"
            tmp = re.search(rep,conf).groups(0)[0]
            if tmp == '1': isPing = False
        except:
            isPing = True
        
        
        
        data = {}
        data['port'] = port
        data['status'] = status
        data['ping'] = isPing
        return data

 def testCpu(self,get,n = 1):
     data = {}
     data['cpuCount'] = psutil.cpu_count();
     if not hasattr(get,'type'): get.type = '0';
     import re;
     cpuinfo = open('/proc/cpuinfo','r').read();
     rep = "model\s+name\s+:\s+(.+)"
     tmp = re.search(rep,cpuinfo);
     data['cpuType'] = ""
     if tmp:
         data['cpuType'] = tmp.groups()[0];
     
     import system
     data['system'] = system.system().GetSystemVersion();
     path = '/www/server/panel/plugin/score/testcpu';
     if not os.path.exists(path): os.system('gcc '+path+'.c -o ' +path + ' -lpthread');
     start = time.time();
     os.system(path + ' 32 ' + get.type);
     end = time.time();
     data['score'] = int(400 * 10 / (end - start));
     if not os.path.exists(path): data['score'] = 0;
     self.writeScore('cpu'+get.type, data['score'])
     return data;
     pass

 def UpdatePanel(self,get):
     #return public.returnMsg(False,'演示服务器，禁止此操作!');
     try:
         if not public.IsRestart(): return public.returnMsg(False,'EXEC_ERR_TASK');
         import web,json
         if int(web.ctx.session.config['status']) == 0:
             public.httpGet(web.ctx.session.home+'/Api/SetupCount?type=Linux');
             public.M('config').where("id=?",('1',)).setField('status',1);
         
         #取回远程版本信息
         if hasattr(web.ctx.session,'updateInfo') == True and hasattr(get,'check') == False:
             updateInfo = web.ctx.session.updateInfo;
         else:
             login_temp = 'data/login.temp';
             if os.path.exists(login_temp):
                 logs = public.readFile(login_temp)
                 os.remove(login_temp);
             else:
                 logs = '';
             import psutil,panelPlugin,system;
             mem = psutil.virtual_memory();
             mplugin = panelPlugin.panelPlugin();
             mplugin.ROWS = 10000;
             panelsys = system.system();
             data = {}
             data['sites'] = str(public.M('sites').count());
             data['ftps'] = str(public.M('ftps').count());
             data['databases'] = str(public.M('databases').count());
             data['system'] = panelsys.GetSystemVersion() + '|' + str(mem.total / 1024 / 1024) + 'MB|' + public.getCpuType() + '*' + str(psutil.cpu_count()) + '|' + public.get_webserver() + '|' + web.ctx.session.version;
             data['system'] += '||'+self.GetInstalleds(mplugin.getPluginList(None));
             data['logs'] = logs
             data['oem'] = ''
             data['intrusion'] = self.get_ssh_intrusion();
             msg = public.getMsg('PANEL_UPDATE_MSG');
             sUrl = web.ctx.session.home + '/Api/updateLinux';
             betaIs = 'data/beta.pl';
             betaStr = public.readFile(betaIs);
             if betaStr:
                 if betaStr.strip() != 'False':
                     sUrl = web.ctx.session.home + '/Api/updateLinuxBeta';
                     msg = public.getMsg('PANEL_UPDATE_MSG_TEST');
             
             betaIs = 'plugin/beta/config.conf';
             betaStr = public.readFile(betaIs);
             if betaStr:
                 if betaStr.strip() != 'False':
                     sUrl = web.ctx.session.home + '/Api/updateLinuxBeta';
                     msg = public.getMsg('PANEL_UPDATE_MSG_TEST');
             
             updateInfo = json.loads(public.httpPost(sUrl,data));
             if not updateInfo: return public.returnMsg(False,"CONNECT_ERR");
             updateInfo['msg'] = msg;
             web.ctx.session.updateInfo = updateInfo;
             
         #检查是否需要升级
         if updateInfo['version'] == web.ctx.session.version:
             try:
                 return public.returnMsg(False,updateInfo['msg']);
             except:
                 return public.returnMsg(False,'PANEL_UPDATE_ERR_NEW');
         
         
         #是否执行升级程序 
         if(updateInfo['force'] == True or hasattr(get,'toUpdate') == True or os.path.exists('data/autoUpdate.pl') == True):
             setupPath = web.ctx.session.setupPath;
             uptype = 'update';
             betaIs = 'plugin/beta/config.conf';
             betaStr = public.readFile(betaIs);
             if betaStr:
                 if betaStr.strip() != 'False': uptype = 'updateTest';
             betaIs = 'data/beta.pl';
             betaStr = public.readFile(betaIs);
             if betaStr:
                 if betaStr.strip() != 'False': uptype = 'updateTest';
             httpUrl = public.get_url();
             if httpUrl: updateInfo['downUrl'] =  httpUrl + '/install/' + uptype + '/LinuxPanel-' + updateInfo['version'] + '.zip';
             
             public.downloadFile(updateInfo['downUrl'],'panel.zip');
             if os.path.getsize('panel.zip') < 1048576: return public.returnMsg(False,"PANEL_UPDATE_ERR_DOWN");
             public.ExecShell('unzip -o panel.zip -d ' + setupPath + '/');
             import compileall
             if os.path.exists(setupPath + '/panel/main.py'): public.ExecShell('rm -f ' + setupPath + '/panel/*.pyc');
             if os.path.exists(setupPath + '/panel/class/common.py'): public.ExecShell('rm -f ' + setupPath + '/panel/class/*.pyc');
             
             compileall.compile_dir(setupPath + '/panel');
             compileall.compile_dir(setupPath + '/panel/class');
             public.ExecShell('rm -f panel.zip');
             web.ctx.session.version = updateInfo['version']
             return public.returnMsg(True,'PANEL_UPDATE',(updateInfo['version'],));
         
         #输出新版本信息
         data = {
             'status' : True,
             'version': updateInfo['version'],
             'updateMsg' : updateInfo['updateMsg']
         };
         
         public.ExecShell('rm -rf /www/server/phpinfo/*');
         return data;
     except Exception,ex:
#.........这里部分代码省略.........