Abstract:
In one aspect, a method includes performing a fast discovery on a virtual network to obtain objects and attributes necessary to display the objects on a user interface, performing a full discovery on the virtual network after the fast discovery and performing rediscovery regularly on the virtual network after the full discovery comprising updating object data based on changes since the last discovery was performed.

Description:
BACKGROUND 
     Over time virtual environments have been used increasingly in storage environment and the scale of their deployment has also increased. For example, a virtual environment may include hundreds to thousands of objects. These objects are added, removed or changed over time. It is important for a host connected to the virtual environment to account for these objects. 
     SUMMARY 
     In one aspect, a method includes performing a fast discovery on a virtual network to obtain objects and attributes necessary to display the objects on a user interface, performing a full discovery on the virtual network after the fast discovery and performing rediscovery regularly on the virtual network after the full discovery comprising updating object data based on changes since the last discovery was performed. 
     In another aspect, an article includes a non-transitory machine-readable medium that stores executable instructions. The instructions cause a machine to perform a fast discovery on a virtual network to obtain objects and attributes necessary to display the objects on a user interface, perform a full discovery on the virtual network after the fast discovery and perform rediscovery regularly on the virtual network after the full discovery comprising updating object data based on changes since the last discovery was performed. 
     In a further aspect, an apparatus includes circuitry configured to perform a fast discovery on a virtual network to obtain objects and attributes necessary to display the objects on a user interface, perform a full discovery on the virtual network after the fast discovery and perform rediscovery regularly on the virtual network after the full discovery comprising updating object data based on changes since the last discovery was performed. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG. 1  is a block diagram of an example of a system that includes a virtual network. 
         FIG. 2  is a block diagram of a particular example of the system of  FIG. 1 . 
         FIG. 3  is a flowchart of an example of a process to perform discovery. 
         FIG. 4  is a flowchart of an example of a process to perform a full discovery. 
         FIG. 5  is a flowchart of an example of a process to perform a rediscovery. 
         FIG. 6  is a flowchart of an example of a process to record discovery times. 
         FIG. 7  is a computer on which the processes of  FIGS. 3 to 6  may be implemented. 
     
    
    
     DETAILED DESCRIPTION 
     One way for the host to keep track of objects in a virtualization environment is to perform discovery routinely. However, with hundreds or thousands of objects in the virtualized environment, discovery must be performed as efficiently as possible. Described herein is an approach to perform discovery of a virtualized environment, 
     Referring to  FIG. 1 , a system  100  includes a host  102 , a virtualized server  106  and a virtual network  104 . The virtual network  104  includes objects such as data stores  112   a , data centers  112   b , virtual machines  112   c , storage devices  112   d  and host systems  112   e . The host  102  includes a cache  120  and a user interface  122 . The host  102  performs discovery on the virtual center  106  through a connection  150  to determine the objects in the virtual network  104 . The virtual center server includes an event database history that records event in the virtual network  104 . The host  102  monitors changes in the virtual network  104  by communicating with the virtual center server  106  to get all the events from the events database history  142  and records the changes in a changes log  132 . 
     The results of the discovery are stored in the cache  120 . The cache  120  includes discovery data  136 . In one example, some or parts of the discovery are initiated using the user interface  122 . 
     Referring to  FIG. 2 , one particular example of the system  100  is a system  100 ′. The system  100 ′ includes the host  102 , the virtual center server  106  and a virtual network  104 ′. The virtual network  104 ′ includes virtual machines  212   a - 212   c , each connected to a respective server  222   a - 222   c . In one example, one or more of the servers  222   a - 222   c  is a VMWARE® ESX®. 
     In one example, each of the servers  222   a - 222   c  includes a respective virtual file system  232   a - 232   c . In one example, one or more of the virtual file systems  232   a - 232   c  is a VMWARE® Virtual File Management System (VFMS). 
     Each server  222   a - 222   b  is coupled to a respective virtual storage device  242   a - 242   c.    
     Referring to  FIG. 3 , an example of a process to perform discovery of a virtual center server  106  by the host  102  is a process  300 . Process  300  performs a fast discovery ( 302 ). For example, the host  102  obtains the objects in the virtual network  104  and a minimum set of attributes which are required for the objects to be displayed on the user interface  10 . 
     Process  300  performs a full discovery ( 308 ). The host  102  retrieves all the objects in the virtual network  104  including their mappings to each other. 
     Process  300  performs rediscovery ( 312 ). For example, the rediscovery is performed on a regular basis. Since most of the data was supplied during processing blocks  302 ,  308  the rediscovery is focused on the changes since the last discovery. 
     Referring to  FIG. 4 , an example of a process to perform a full discovery (e.g., processing block  308  in  FIG. 3 ) is a process  400 . Process  400  determines a list of the data stores  112   a  ( 402 ) and determines the data centers  112   b  that each data store  112   a  belongs to ( 408 ). 
     Process  400  resolves each data store  112   a  to an underlying storage device  112   d  ( 412 ). For example, a host system  112   e  is found for each data store and the mounted volume information on the host system  112   e  is read and mounted volumes are resolved to the storage device  112   d.    
     Once the storage device  112   d  for each mounted volume is known, process  400  looks up the mounted volume name in the list of data stores  112   a  ( 422 ). 
     Once a match is found for a mounted volume name in the list of data stores  112   e , process  400  assigns the mounted volume and the storage device  112   d  to a corresponding data store  112   a  ( 428 ). After finding a match for each mounted volume on the first host system  112   e , process  400  repeats processing blocks  412 ,  422 ,  428  for each host system ( 428 ). 
     Referring to  FIG. 5 , an example of a process to perform rediscovery (e.g., processing block  312  in  FIG. 3 ) is a process  500 . Process  500  determines if there are any new events since the last discovery ( 504 ). For example, process  500  checks a time stamp of the last discovery in the cache  120  and determines if there have been any changes since the last time stamp. 
     Process  500  checks for the event type of each new event ( 508 ). Process  500  determines if any event type matches any relevant objects (i.e., objects whose discovery is of interest to, for example, a user) ( 514 ). 
     If any event type matches, process  500  generates a change logs record for that object in the changes log  132  ( 514 ). If the event type does not match, process  500  determines if there any new events ( 528 ), and if so, goes to the next event ( 536 ) and repeats processing block  508 . If there are no more new events, process  500  updates the discovery data with the changes recorded in the changes log  132  ( 532 ) 
     Referring to  FIG. 6 , an example of a process to record discovery times is a process  600 . Process  600  determines if a discovery has been performed ( 604 ). For example, process  600  determines if a fast, full or rediscovery has been performed. If a discovery has been performed, process  600  saves a time stamp at the cache  120  recording the time of the fast, full or rediscovery completion ( 608 ). 
     Referring to  FIG. 7 , in one example, a host  102  is a computer  102 ′. The computer  102 ′ includes a processor  702 , a volatile memory  704 , a non-volatile memory  706  (e.g., hard disk) and the user interface (UI)  122  (e.g., a mouse, a keyboard, a display, touch screen and so forth). The non-volatile memory  706  stores computer instructions  712 , an operating system  716  and data  718  including the changes log  132  and the discovery data  136 . In one example, the computer instructions  712  are executed by the processor  702  out of volatile memory  704  to perform all or part of the processes described herein (e.g., processes  300  to  600 ). 
     The processes described herein (e.g., processes  300  to  600 ) are not limited to use with the hardware and software of  FIG. 7 ; they may find applicability in any computing or processing environment and with any type of machine or set of machines that is capable of running a computer program. The processes described herein may be implemented in hardware, software, or a combination of the two. The processes described herein may be implemented in computer programs executed on programmable computers/machines that each includes a processor, a non-transitory machine-readable medium or other article of manufacture that is readable by the processor (including volatile and non-volatile memory and/or storage elements), at least one input device, and one or more output devices. Program code may be applied to data entered using an input device to perform any of the processes described herein and to generate output information. 
     The system may be implemented, at least in part, via a computer program product, (e.g., in a non-transitory machine-readable storage medium), for execution by, or to control the operation of, data processing apparatus (e.g., a programmable processor, a computer, or multiple computers)). Each such program may be implemented in a high level procedural or object-oriented programming language to communicate with a computer system. However, the programs may be implemented in assembly or machine language. The language may be a compiled or an interpreted language and it may be deployed in any form, including as a stand-alone program or as a module, component, subroutine, or other unit suitable for use in a computing environment. A computer program may be deployed to be executed on one computer or on multiple computers at one site or distributed across multiple sites and interconnected by a communication network. A computer program may be stored on a non-transitory machine-readable medium that is readable by a general or special purpose programmable computer for configuring and operating the computer when the non-transitory machine-readable medium is read by the computer to perform the processes described herein. For example, the processes described herein may also be implemented as a non-transitory machine-readable storage medium, configured with a computer program, where upon execution, instructions in the computer program cause the computer to operate in accordance with the processes. A non-transitory machine-readable medium may include but is not limited to a hard drive, compact disc, flash memory, non-volatile memory, volatile memory, magnetic diskette and so forth but does not include a transitory signal per se. The processes described herein are not limited to the specific examples described. 
     For example, the processes  300  to  600  are not limited to the specific processing order of  FIGS. 3 to 6 , respectively. Rather, any of the processing blocks of  FIGS. 3 to 6  may be re-ordered, combined or removed, performed in parallel or in serial, as necessary, to achieve the results set forth above. 
     The processing blocks (for example, in the processes  300  to  600 ) associated with implementing the system may be performed by one or more programmable processors executing one or more computer programs to perform the functions of the system. All or part of the system may be implemented as, special purpose logic circuitry (e.g., an FPGA (field-programmable gate array) and/or an ASIC (application-specific integrated circuit)). 
     Elements of different embodiments described herein may be combined to form other embodiments not specifically set forth above. Other embodiments not specifically described herein are also within the scope of the following claims.