sdn

 #!/usr/bin/env python

 #from mininet.cli import CLI

 #from mininet.link import Link

 #from mininet.net import Mininet

 #from mininet.node import RemoteController

 #from mininet.trm import makeTerm

 from mininet.topo import Topo

 class spanning_tree( Topo ):

         def __init__( self ):

                 Topo.__init__(self)

                 host1 = self.addHost('h1')

                 host2 = self.addHost('h2')

                 host3 = self.addHost('h3')

                 switch1 = self.addSwitch( 's1' )

                 switch2 = self.addSwitch( 's2' )

                 switch3 = self.addSwitch( 's3' )

                 self.addLink(switch1, host1)

                 self.addLink(switch2, host2)

                 self.addLink(switch3, host3)

                 self.addLink(switch1, switch2)

                 self.addLink(switch2, switch3)

                 self.addLink(switch1, switch3)

 topos = {'mytopo': ( lambda:spanning_tree())}

环路拓扑结构，可能造成广播风暴：

手动编写的拓扑

 #!/usr/bin/env python

 from mininet.cli import CLI

 from mininet.node import Node

 from mininet.link import Link

 from mininet.net import Mininet

 from mininet.node import RemoteController

 from mininet.term import makeTerm

 if '__main__' == __name__:

     net = Mininet(controller=RemoteController)

     c0 = net.addController('c0')

     s1 = net.addSwitch('s1')

     s2 = net.addSwitch('s2')

     s3 = net.addSwitch('s3')

     h1 = net.addHost('h1')

     h2 = net.addHost('h2')

     h3 = net.addHost('h3')

     Link(s1, h1)

     Link(s2, h2)

     Link(s3, h3)

     Link(s1, s2)

     Link(s2, s3)

     Link(s1, s3)

     net.build()

     c0.start()

     s1.start([c0])

     s2.start([c0])

     s3.start([c0])

     net.terms.append(makeTerm(c0))

     net.terms.append(makeTerm(s1))

     net.terms.append(makeTerm(s2))

     net.terms.append(makeTerm(s3))

     net.terms.append(makeTerm(h1))

     net.terms.append(makeTerm(h2))

     net.terms.append(makeTerm(h3))

     CLI(net)

     net.stop()

图像化生成的脚本：

#!/usr/bin/python

from mininet.net import Mininet

from mininet.node import Controller, RemoteController, OVSController

from mininet.node import CPULimitedHost, Host, Node

from mininet.node import OVSKernelSwitch, UserSwitch

from mininet.node import IVSSwitch

from mininet.cli import CLI

from mininet.log import setLogLevel, info

from mininet.link import TCLink, Intf

from subprocess import call

def myNetwork():

    net = Mininet( topo=None,

                   build=False,

                   ipBase='10.0.0.0/8')

    info( '*** Adding controller\n' )

    c0=net.addController(name='c0',

                      controller=Controller,

                      protocol='tcp',

                      port=6633)

    info( '*** Add switches\n')

    s2 = net.addSwitch('s2', cls=OVSKernelSwitch)

    s1 = net.addSwitch('s1', cls=OVSKernelSwitch)

    s3 = net.addSwitch('s3', cls=OVSKernelSwitch)

    info( '*** Add hosts\n')

    h2 = net.addHost('h2', cls=Host, ip='10.0.0.2', defaultRoute=None)

    h1 = net.addHost('h1', cls=Host, ip='10.0.0.1', defaultRoute=None)

    h3 = net.addHost('h3', cls=Host, ip='10.0.0.3', defaultRoute=None)

    info( '*** Add links\n')

    net.addLink(h1, s1)

    net.addLink(s1, s2)

    net.addLink(s1, s3)

    net.addLink(s2, s3)

    net.addLink(h2, s2)

    net.addLink(s3, h3)

    info( '*** Starting network\n')

    net.build()

    info( '*** Starting controllers\n')

    for controller in net.controllers:

        controller.start()

    info( '*** Starting switches\n')

    net.get('s2').start([c0])

    net.get('s1').start([c0])

    net.get('s3').start([c0])

    info( '*** Post configure switches and hosts\n')

    CLI(net)

    net.stop()

if __name__ == '__main__':

    setLogLevel( 'info' )

    myNetwork()

根据miniedit绘制拓扑生成的脚本：

#!/usr/bin/python

from mininet.net import Mininet

from mininet.node import Controller, RemoteController, OVSController

from mininet.node import CPULimitedHost, Host, Node

from mininet.node import OVSKernelSwitch, UserSwitch

from mininet.node import IVSSwitch

from mininet.cli import CLI

from mininet.log import setLogLevel, info

from mininet.link import TCLink, Intf

from subprocess import call

def myNetwork():

    net = Mininet( topo=None,

                   build=False,

                   ipBase='10.0.0.0/8')

    info( '*** Adding controller\n' )

    c0=net.addController(name='c0',

                      controller=Controller,

                      protocol='tcp',

                      port=6633)

    info( '*** Add switches\n')

    s10 = net.addSwitch('s10', cls=OVSKernelSwitch)

    s3 = net.addSwitch('s3', cls=OVSKernelSwitch)

    s14 = net.addSwitch('s14', cls=OVSKernelSwitch)

    s19 = net.addSwitch('s19', cls=OVSKernelSwitch)

    s4 = net.addSwitch('s4', cls=OVSKernelSwitch)

    s20 = net.addSwitch('s20', cls=OVSKernelSwitch)

    s9 = net.addSwitch('s9', cls=OVSKernelSwitch)

    s11 = net.addSwitch('s11', cls=OVSKernelSwitch)

    s12 = net.addSwitch('s12', cls=OVSKernelSwitch)

    s15 = net.addSwitch('s15', cls=OVSKernelSwitch)

    s1 = net.addSwitch('s1', cls=OVSKernelSwitch)

    s6 = net.addSwitch('s6', cls=OVSKernelSwitch)

    s5 = net.addSwitch('s5', cls=OVSKernelSwitch)

    s16 = net.addSwitch('s16', cls=OVSKernelSwitch)

    s17 = net.addSwitch('s17', cls=OVSKernelSwitch)

    s7 = net.addSwitch('s7', cls=OVSKernelSwitch)

    s2 = net.addSwitch('s2', cls=OVSKernelSwitch)

    s18 = net.addSwitch('s18', cls=OVSKernelSwitch)

    s8 = net.addSwitch('s8', cls=OVSKernelSwitch)

    s13 = net.addSwitch('s13', cls=OVSKernelSwitch)

    info( '*** Add hosts\n')

    h15 = net.addHost('h15', cls=Host, ip='10.0.0.15', defaultRoute=None)

    h6 = net.addHost('h6', cls=Host, ip='10.0.0.6', defaultRoute=None)

    h16 = net.addHost('h16', cls=Host, ip='10.0.0.16', defaultRoute=None)

    h10 = net.addHost('h10', cls=Host, ip='10.0.0.10', defaultRoute=None)

    h7 = net.addHost('h7', cls=Host, ip='10.0.0.7', defaultRoute=None)

    h8 = net.addHost('h8', cls=Host, ip='10.0.0.8', defaultRoute=None)

    h14 = net.addHost('h14', cls=Host, ip='10.0.0.14', defaultRoute=None)

    h1 = net.addHost('h1', cls=Host, ip='10.0.0.1', defaultRoute=None)

    h9 = net.addHost('h9', cls=Host, ip='10.0.0.9', defaultRoute=None)

    h4 = net.addHost('h4', cls=Host, ip='10.0.0.4', defaultRoute=None)

    h12 = net.addHost('h12', cls=Host, ip='10.0.0.12', defaultRoute=None)

    h5 = net.addHost('h5', cls=Host, ip='10.0.0.5', defaultRoute=None)

    h2 = net.addHost('h2', cls=Host, ip='10.0.0.2', defaultRoute=None)

    h11 = net.addHost('h11', cls=Host, ip='10.0.0.11', defaultRoute=None)

    h3 = net.addHost('h3', cls=Host, ip='10.0.0.3', defaultRoute=None)

    h13 = net.addHost('h13', cls=Host, ip='10.0.0.13', defaultRoute=None)

    info( '*** Add links\n')

    net.addLink(s1, s5)

    net.addLink(s1, s7)

    net.addLink(s1, s9)

    net.addLink(s1, s11)

    net.addLink(s2, s5)

    net.addLink(s2, s7)

    net.addLink(s2, s9)

    net.addLink(s2, s11)

    net.addLink(s3, s6)

    net.addLink(s3, s8)

    net.addLink(s3, s10)

    net.addLink(s3, s12)

    net.addLink(s4, s6)

    net.addLink(s4, s8)

    net.addLink(s4, s10)

    net.addLink(s4, s12)

    net.addLink(s5, s13)

    net.addLink(s6, s14)

    net.addLink(s6, s13)

    net.addLink(s5, s14)

    net.addLink(s7, s15)

    net.addLink(s8, s16)

    net.addLink(s8, s15)

    net.addLink(s7, s16)

    net.addLink(s9, s17)

    net.addLink(s10, s18)

    net.addLink(s10, s17)

    net.addLink(s9, s18)

    net.addLink(s11, s19)

    net.addLink(s12, s20)

    net.addLink(s12, s19)

    net.addLink(s11, s20)

    net.addLink(s13, h1)

    net.addLink(s13, h2)

    net.addLink(s14, h3)

    net.addLink(s14, h4)

    net.addLink(s15, h5)

    net.addLink(s15, h6)

    net.addLink(s16, h7)

    net.addLink(s16, h8)

    net.addLink(s17, h9)

    net.addLink(s17, h10)

    net.addLink(s18, h11)

    net.addLink(s18, h12)

    net.addLink(s19, h13)

    net.addLink(s19, h14)

    net.addLink(s20, h16)

    net.addLink(s20, h15)

    info( '*** Starting network\n')

    net.build()

    info( '*** Starting controllers\n')

    for controller in net.controllers:

        controller.start()

    info( '*** Starting switches\n')

    net.get('s10').start([])

    net.get('s3').start([c0])

    net.get('s14').start([])

    net.get('s19').start([])

    net.get('s4').start([c0])

    net.get('s20').start([])

    net.get('s9').start([])

    net.get('s11').start([])

    net.get('s12').start([])

    net.get('s15').start([])

    net.get('s1').start([c0])

    net.get('s6').start([])

    net.get('s5').start([])

    net.get('s16').start([])

    net.get('s17').start([])

    net.get('s7').start([])

    net.get('s2').start([c0])

    net.get('s18').start([])

    net.get('s8').start([])

    net.get('s13').start([])

    info( '*** Post configure switches and hosts\n')

    CLI(net)

    net.stop()

if __name__ == '__main__':

    setLogLevel( 'info' )

    myNetwork()

手动编写的fat-tree拓扑结构：

#!/usr/bin/env python

from mininet.cli import CLI

from mininet.node import Node

from mininet.link import Link

from mininet.net import Mininet

from mininet.node import RemoteController

from mininet.term import makeTerm

if '__main__' == __name__:

    net = Mininet(controller=RemoteController)

    c0 = net.addController('c0')

    s1 = net.addSwitch('s1')

    s2 = net.addSwitch('s2')

    s3 = net.addSwitch('s3')

    s4 = net.addSwitch('s4')

    s5 = net.addSwitch('s5')

    s6 = net.addSwitch('s6')

    s7 = net.addSwitch('s7')

    s8 = net.addSwitch('s8')

    s9 = net.addSwitch('s9')

    s10 = net.addSwitch('s10')

    s11 = net.addSwitch('s11')

    s12 = net.addSwitch('s12')

    s13 = net.addSwitch('s13')

    s14 = net.addSwitch('s14')

    s15 = net.addSwitch('s15')

    s16 = net.addSwitch('s16')

    s17 = net.addSwitch('s17')

    s18 = net.addSwitch('s18')

    s19 = net.addSwitch('s19')

    s20 = net.addSwitch('s20')

    h1 = net.addHost('h1')

    h2 = net.addHost('h2')

    h3 = net.addHost('h3')

    h4 = net.addHost('h4')

    h5 = net.addHost('h5')

    h6 = net.addHost('h6')

    h7 = net.addHost('h7')

    h8 = net.addHost('h8')

    h9 = net.addHost('h9')

    h10 = net.addHost('h10')

    h11 = net.addHost('h11')

    h12 = net.addHost('h12')

    h13 = net.addHost('h13')

    h14 = net.addHost('h14')

    h15 = net.addHost('h15')

    h16 = net.addHost('h16')

    Link(s1, s5)

    Link(s1, s7)

    Link(s1, s9)

    Link(s1, s11)

    Link(s2, s5)

    Link(s2, s7)

    Link(s2, s9)

    Link(s2, s11)

    Link(s3, s6)

    Link(s3, s8)

    Link(s3, s10)

    Link(s3, s12)

    Link(s2, s11)

    Link(s4, s6)

    Link(s4, s8)

    Link(s4, s10)

    Link(s4, s12)

    Link(s5, s13)

    Link(s5, s14)

    Link(s6, s13)

    Link(s6, s14)

    Link(s7, s15)

    Link(s7, s16)

    Link(s8, s15)

    Link(s8, s16)

    Link(s9, s17)

    Link(s9, s18)

    Link(s10, s17)

    Link(s10, s18)

    Link(s11, s19)

    Link(s11, s20)

    Link(s12, s19)

    Link(s12, s20)

    s = [s13, s14, s15, s16, s17, s18, s19, s20]

    h = [h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11, h12, h13, h14, h15, h16]

    j = 0

    count = 0

    for i in range(0, len(s)):

        count = 0

        while count < 2:

            Link(s[i], h[j])

            j += 1

            count += 1

    net.build()

    c0.start()

    s1.start([c0])

    s2.start([c0])

    s3.start([c0])

    s4.start([c0])

 #   net.terms.append(makeTerm(c0))

 #   net.terms.append(makeTerm(s1))

 #   net.terms.append(makeTerm(s2))

 #   net.terms.append(makeTerm(s3))

 #   net.terms.append(makeTerm(h1))

 #   net.terms.append(makeTerm(h2))

 #   net.terms.append(makeTerm(h3))

    CLI(net)

    net.stop()

开源fat-tree拓扑结构：

from mininet.net import Mininet

from mininet.node import Controller, RemoteController

from mininet.cli import CLI

from mininet.log import setLogLevel, info

from mininet.link import Link, Intf, TCLink

from mininet.topo import Topo

from mininet.util import dumpNodeConnections

import logging

import os

logging.basicConfig(level=logging.DEBUG)

logger = logging.getLogger( __name__ )

class HugeTopo(Topo):

    logger.debug("Class HugeTopo")

    CoreSwitchList = []

    AggSwitchList = []

    EdgeSwitchList = []

    HostList = []

    iNUMBER = 0

    def __init__(self):

        logger.debug("Class HugeTopo init")

        iNUMBER = 4

        self.iNUMBER = iNUMBER

        self.iCoreLayerSwitch = iNUMBER

        self.iAggLayerSwitch = iNUMBER * 2

        self.iEdgeLayerSwitch = iNUMBER * 2

        self.iHost = self.iEdgeLayerSwitch * 2

        Topo.__init__(self)

    def createTopo(self):

        logger.debug("Start create Core Layer Switch")

        self.createCoreLayerSwitch(self.iCoreLayerSwitch)

        logger.debug("Start create Agg Layer Switch")

        self.createAggLayerSwitch(self.iAggLayerSwitch)

        logger.debug("Start create Edge Layer Switch")

        self.createEdgeLayerSwitch(self.iEdgeLayerSwitch)

        logger.debug("Satrt create Host")

        self.createHost(self.iHost)

    def createCoreLayerSwitch(self, NUMBER):

        logger.debug("Create Core Layer")

        for x in range(1, NUMBER+1):

            PERFIX = ""

            if x >= int(10):

                PERFIX = ""

            self.CoreSwitchList.append(self.addSwitch(PERFIX + str(x)))

    def createAggLayerSwitch(self, NUMBER):

                logger.debug("Create Agg Layer")

                for x in range(1, NUMBER+1):

                        PERFIX = ""

                        if x >= int(10):

                                PERFIX = ""

                        self.AggSwitchList.append(self.addSwitch(PERFIX + str(x)))

    def createEdgeLayerSwitch(self, NUMBER):

                logger.debug("Create Edge Layer")

                for x in range(1, NUMBER+1):

                        PERFIX = ""

                        if x >= int(10):

                                PERFIX = ""

                        self.EdgeSwitchList.append(self.addSwitch(PERFIX + str(x)))

    def createHost(self, NUMBER):

                logger.debug("Create Host")

                for x in range(1, NUMBER+1):

                        PERFIX = ""

                        if x >= int(10):

                                PERFIX = ""

                        self.HostList.append(self.addHost(PERFIX + str(x)))

    def createLink(self):

        logger.debug("Create Core to Agg")

        for x in range(0, self.iAggLayerSwitch, 2):

            self.addLink(self.CoreSwitchList[0], self.AggSwitchList[x], bw=1000, loss=5)

            self.addLink(self.CoreSwitchList[1], self.AggSwitchList[x], bw=1000, loss=5)

        for x in range(1, self.iAggLayerSwitch, 2):

                        self.addLink(self.CoreSwitchList[2], self.AggSwitchList[x], bw=1000, loss=5)

                        self.addLink(self.CoreSwitchList[3], self.AggSwitchList[x], bw=1000, loss=5)

        logger.debug("Create Agg to Edge")

                for x in range(0, self.iAggLayerSwitch, 2):

                        self.addLink(self.AggSwitchList[x], self.EdgeSwitchList[x], bw=100)

                        self.addLink(self.AggSwitchList[x], self.EdgeSwitchList[x+1], bw=100)

            self.addLink(self.AggSwitchList[x+1], self.EdgeSwitchList[x], bw=100)

                        self.addLink(self.AggSwitchList[x+1], self.EdgeSwitchList[x+1], bw=100)

        logger.debug("Create Edge to Host")

                for x in range(0, self.iEdgeLayerSwitch):

                        self.addLink(self.EdgeSwitchList[x], self.HostList[2*x])

                        self.addLink(self.EdgeSwitchList[x], self.HostList[2*x+1])

def enableSTP():

    for x in range(1, 5):

        cmd = "ovs-vsctl set Bridge %s stp_enable=true" % ("" + str(x))

        os.system(cmd)

        print cmd

    for x in range(1, 9):

        cmd = "ovs-vsctl set Bridge %s stp_enable=true" % ("" + str(x))

                os.system(cmd)

                print cmd

        cmd = "ovs-vsctl set Bridge %s stp_enable=true" % ("" + str(x))

                os.system(cmd)

                print cmd

def iperfTest(net, topo):

    logger.debug("Start iperfTest:")

    h1000, h1015, h1016 = net.get(topo.HostList[0], topo.HostList[14], topo.HostList[15])

    h1000.popen('iperf -s -u -i 1 > iperf_server_differentPod_result', shell=True)

    h1015.popen('iperf -s -u -i 1 > iperf_server_samePod_result', shell=True)

    h1016.cmdPrint('iperf -c' + h1000.IP() + ' -u -t 10 -i 1 -b 100m')

    h1016.cmdPrint('iperf -c' + h1015.IP() + ' -u -t 10 -i 1 -b 100m')

def pingTest(net):

    logger.debug("Start Test all network")

    net.pingAll()

def createTopo():

    logging.debug("LV1 Create HugeTopo")

    topo = HugeTopo()

    topo.createTopo()

    topo.createLink()

    logging.debug("LV1 Start Mininet")

    CONTROLLER_IP = "192.168.116.128"

    CONTROLLER_PORT = 6633

    net = Mininet(topo=topo, link=TCLink, controller=None)

    net.addController('controller', controller=RemoteController,ip=CONTROLLER_IP, port=CONTROLLER_PORT)

    net.start()

    logger.debug("LV1 dumpNode")

    enableSTP()

    dumpNodeConnections(net.hosts)

    pingTest(net)

    iperfTest(net, topo)

    CLI(net)

    net.stop()

if __name__ == '__main__':

    setLogLevel('info')

    if os.getuid() != 0:

        logger.debug("You are not root")

    elif os.getuid() == 0:

        createTopo()

sdn的更多相关文章

SDN/NFV运营商商业化部署
三大运营商发布未来网络架构,并逐步加快SDN/NFV商业化部署的步伐.中国联通发布其新一代网络架构<CUBE-Net 2.0白皮书>,并与20多家合作伙伴共同启动了“新一代网络”合作研发计 ...
SDN/NFV若干问题
1.首先谈一谈网络技术和组网技术的关系网络可分为两层:业务网.承载网.业务网主要是组织业务系统,而承载网主要是用来传输信息流:包括传送网(点到点数据专线).数据网(端到端连接).内容分发网(点到多点 ...
解读SDN的东西、南北向接口
北向接口(Northbound Interface)是为厂家或运营商进行接入和管理网络的接口,即向上提供的接口. 南向接口(Southbound Interface)是提供对其他厂家网元的管理功能,支 ...
SDN:motivation
今天公交车上看了会SDN一本介绍性的书籍,具体名字不记得了.我想,我已经在实验室呆了很久的时间的,接触SDN也有一段时间了.对SDN的一些基本的知识还是需要好好整理一番.当然,这里只是一个随笔,想到什 ...
SDN与NFV技术在云数据中心的规模应用探讨
Neo 2016-1-29 | 发表评论编者按:以云数据中心为切入点,首先对SDN领域中的叠加网络.SDN控制器.VxLAN 3种重要技术特点进行了研究,接下来对NFV领域中的通用服务器性能.服务链 ...
SDDC－SDN－SDS
SDDCSDNSDS软件定义存储是一个较大的行业发展趋势,这个行业还包括软件定义网络(SDN)和软件定义数据中心(SDDC). SDDC依赖于虚拟化和云计算技术, SDDC的目标是虚拟化数据中心的一切 ...
SDN三种模型解析
数十年前,计算机科学家兼网络作家Andrew S. Tanenbaum讽刺标准过多难以选择,当然现在也是如此,比如软件定义网络模型的数量也很多.但是在考虑部署软件定义网络(SDN)或者试点之前,首先需 ...
浅谈SDN和NFV之间的关系
一个行业固定设备的折旧周期很长,任何变革的发生都绝非易事,但是网络却一次性面临两项革新--软件定义网络(SDN)和网络功能虚拟化(NFV),在变革网络的过程中,二者若想取得成功可能会依赖彼此的技术,或 ...
SDN跟网络虚拟化的完美结合
SDN跟网络虚拟化的完美结合之前说过,所谓的“SDN最适合的领域是数据中心”的说法,笔者认为更准确的说法应该是SDN最适合的领域是数据中心中的网络虚拟化应用.为什么说SDN 非常适合用在网络虚拟化中 ...
深度解析SDN——利益、战略、技术、实践（实战派专家力作，业内众多专家推荐）
深度解析SDN——利益.战略.技术.实践(实战派专家力作,业内众多专家推荐) 张卫峰编 ISBN 978-7-121-21821-7 2013年11月出版定价:59.00元 232页 16开 ...

随机推荐

[转]你不需要jQuery
完全没有否定jQuery的意思,jQuery是一个神奇的.非常有用的工具,可以节省我们大量的时间. 但是,有些时候,我们只需要jQuery的一个小功能,来完成一个小任务,完全没有必要加载整个jQuer ...
Urimoo做试卷
Urimoo做试卷题目描述 SBJ最近收到了n张数学卷子,这些卷子的标号为0-n−1,他不想写这些卷子,于是他的好朋友SCX热心地想要帮他撕掉n−1张卷子.SBJ很高兴,但是SCX说,他撕试卷的顺序 ...
【转】如何把Json格式字符写进text文件中
http://www.cnblogs.com/insus/p/4306640.html http://json2csharp.chahuo.com/ 本篇一步一步学习怎样把显示于网页的json格式的字 ...
TiD大会学习心得之沟通交流
沟通交流是敏捷成功的关键要素,据相关调查阻碍敏捷的主要原因都与人有关:例如缺乏领导支持.团队缺乏协作精神.公司文化与敏捷相冲突等等:同时沟通交流也是团队建设.教练自身成长的重要支柱.下面结合在< ...
SEO实战宝典阅读笔记
1. 对搜索引擎更友好 1.1 sitemap sitemap自动生成 https://www.xml-sitemaps.com 谷歌 sitemap.xml 百度 sitemap.html 1.2 ...
H264编码原理以及I帧、B和P帧详解
H264是新一代的编码标准,以高压缩高质量和支持多种网络的流媒体传输著称,在编码方面,我理解的他的理论依据是:参照一段时间内图像的统计结果表明,在相邻几幅图像画面中,一般有差别的像素只有10%以内的点 ...
Python学习之路【目录】
本系列博文包含 Python基础.前端开发.Web框架.缓存以及队列等,希望可以给正在学习编程的童鞋提供一点帮助!!! 目录: Python学习[第一篇]python简介 Python学习[第二篇]p ...
Eclipse设置选中高亮显示
高亮显示选中的变量对于程序员编程很有帮助,正常情况下Eclipse选中变量时都会高亮显示,可能软件冲突导致高亮显示失效,通过如下方法可以进行恢复. 单击IDE顶部Window菜单下的Prefences ...
wdcp安装
下载安装(ssh登录服务器,执行如下操作即可,需要用到root用户权限来安装)v3版本已经发布,更多可看论坛 wdCP v3版本讨论区更多安装请看 http://www.wdlinux.cn/bbs/ ...
28个Unix/Linux的命令行神器_转
28个Unix/Linux的命令行神器下面是Kristóf Kovács收集的28个Unix/Linux下的28个命令行下的工具,有一些是大家熟悉的,有一些是非常有用的,有一些是不为人知的.这些工具 ...

sdn

sdn的更多相关文章

随机推荐

热门专题