replaced print calls with logging calls

tests/test_common_pyvmomi.py

@@ -6,11 +6,14 @@
 from mock import Mock, MagicMock, create_autospec, patch
 from pyVmomi import vim
 from pyVim.connect import SmartConnect, Disconnect
+from pycommon.pyVmomiService import pyVmomiService
 from testCredentials import TestCredentials
 sys.path.append(os.path.join(os.path.dirname(__file__), '../vCenterShell'))
 
-from vCenterShell.pycommon.pyVmomiService import pyVmomiService
-
+from vCenterShell.pycommon.logger import getLogger
+from vCenterShell.pycommon.logger import configure_loglevel
+logger = getLogger(__name__)
+configure_loglevel("INFO", "INFO", os.path.join(__file__, os.pardir, os.pardir, 'logs', 'vCenter.log'))
 
 class ignore_test_common_pyvmomi(unittest.TestCase):
     def setUp(self):
@@ -35,7 +38,7 @@ def integration_clone_vm_destory(self):
         '#act'
         now = datetime.now()
         res = pv_service.clone_vm(params)
-        print 'clone took: %s' % (str(datetime.now() - now))
+        logger.debug('clone took: %s' % (str(datetime.now() - now)))
 
         '#assert'
         self.assertTrue(type(res.vm), vim.VirtualMachine)
@@ -44,7 +47,7 @@ def integration_clone_vm_destory(self):
         now = datetime.now()
         if res.error is None and res.vm is not None:
             destroyed = pv_service.destroy_vm(res.vm)
-        print 'destroy took: %s' % (str(datetime.now() - now))
+        logger.debug('destroy took: %s' % (str(datetime.now() - now)))
         self.assertIsNone(destroyed)
 
     def test_clone_vm_power_on_false(self):

tests/test_destroyVirtualMachineCommand.py

@@ -5,7 +5,7 @@
 import unittest
 from mock import Mock, create_autospec, MagicMock
 import qualipy.scripts.cloudshell_scripts_helpers as helpers
-from vCenterShell.commands.destroyVirtualMachineCommand import DestroyVirtualMachineCommand
+from vCenterShell.commands.DestroyVirtualMachineCommand import DestroyVirtualMachineCommand
 from pyVmomi import vim
 from vCenterShell.models.VCenterTemplateModel import VCenterTemplateModel
 from vCenterShell.models.VMClusterModel import VMClusterModel

vCenterShell/commands/DeployFromTemplateCommand.py

@@ -3,7 +3,10 @@
 from vCenterShell.commands.BaseCommand import BaseCommand
 from vCenterShell.pycommon.common_collection_utils import first_or_default
 from vCenterShell.pycommon.common_name_utils import generate_unique_name
-
+from vCenterShell.pycommon.logger import getLogger
+from vCenterShell.pycommon.logger import configure_loglevel
+logger = getLogger(__name__)
+configure_loglevel("INFO", "INFO", os.path.join(__file__, os.pardir, os.pardir, os.pardir, 'logs', 'vCenter.log'))
 
 class DeployFromTemplateCommand(BaseCommand):
     """ Command to Create a VM from a template """
@@ -55,26 +58,26 @@ def get_data_for_deployment(self):
 
         # get vCenter resource name, template name, template folder
         template_model = self.cs_retriever_service.getVCenterTemplateAttributeData(resource_context)
-        print "Template: {0}, Folder: {1}, vCenter: {2}".format(template_model.template_name, template_model.vm_folder, template_model.vCenter_resource_name)
+        logger.info("Template: {0}, Folder: {1}, vCenter: {2}".format(template_model.template_name, template_model.vm_folder, template_model.vCenter_resource_name))
 
         # get power state of the cloned VM
         power_on = self.cs_retriever_service.getPowerStateAttributeData(resource_context)
-        print "Power On: {0}".format(power_on)
+        logger.info("Power On: {0}".format(power_on))
 
         # get cluster and resource pool
         vm_cluster_model = self.cs_retriever_service.getVMClusterAttributeData(resource_context)
-        print "Cluster: {0}, Resource Pool: {1}".format(vm_cluster_model.cluster_name, vm_cluster_model.resource_pool)
+        logger.info("Cluster: {0}, Resource Pool: {1}".format(vm_cluster_model.cluster_name, vm_cluster_model.resource_pool))
 
         # get datastore
         datastore_name = self.cs_retriever_service.getVMStorageAttributeData(resource_context)
-        print "Datastore: {0}".format(datastore_name)
+        logger.info("Datastore: {0}".format(datastore_name))
 
         connection_details = self.resource_connection_details_retriever.connection_details(
             template_model.vCenter_resource_name)
-        print "Connecting to: {0}, As: {1}, Pwd: {2}, Port: {3}".format(connection_details.host,
+        logger.info("Connecting to: {0}, As: {1}, Pwd: {2}, Port: {3}".format(connection_details.host,
                                                                         connection_details.username,
                                                                         connection_details.password,
-                                                                        connection_details.port)
+                                                                        connection_details.port))
 
         return DataHolder(resource_context,
                           connection_details,

vCenterShell/commands/DestroyVirtualMachineCommand.py

@@ -10,6 +10,10 @@
 from vCenterShell.pycommon.common_name_utils import generate_unique_name
 from vCenterShell.pycommon.CloudshellDataRetrieverService import *
 from vCenterShell.commands.BaseCommand import BaseCommand
+from vCenterShell.pycommon.logger import getLogger
+from vCenterShell.pycommon.logger import configure_loglevel
+logger = getLogger(__name__)
+configure_loglevel("INFO", "INFO", os.path.join(__file__, os.pardir, os.pardir, os.pardir, 'logs', 'vCenter.log'))
 
 
 class DestroyVirtualMachineCommand(BaseCommand):
@@ -32,7 +36,7 @@ def execute(self):
         vCenter_resource_name = inventory_path_data.vCenter_resource_name
         vm_folder = inventory_path_data.vm_folder
 
-        print "Folder: {0}, vCenter: {1}".format(vm_folder, vCenter_resource_name)
+        logger.info("Folder: {0}, vCenter: {1}".format(vm_folder, vCenter_resource_name))
 
         reservation_id = helpers.get_reservation_context_details().id
         session = helpers.get_api_session()
@@ -41,8 +45,8 @@ def execute(self):
         # get vCenter connection details from vCenter resource
         vCenterConn = self.csRetrieverService.getVCenterConnectionDetails(session, vCenter_details)
 
-        print "Connecting to: {0}, As: {1}, Pwd: {2}".format(vCenterConn["vCenter_url"], vCenterConn["user"],
-                                                             vCenterConn["password"])
+        logger.info("Connecting to: {0}, As: {1}, Pwd: {2}".format(vCenterConn["vCenter_url"], vCenterConn["user"],
+                                                             vCenterConn["password"]))
 
         # connect
         si = self.pvService.connect(vCenterConn["vCenter_url"], vCenterConn["user"], vCenterConn["password"])

vCenterShell/commands/DvPortGroupCreator.py

@@ -1,7 +1,11 @@
+import os
 from pyVmomi import vim
 from vCenterShell.pycommon.pyVmomiService import *
 from vCenterShell.pycommon.SynchronousTaskWaiter import *
-
+from vCenterShell.pycommon.logger import getLogger
+from vCenterShell.pycommon.logger import configure_loglevel
+logger = getLogger(__name__)
+configure_loglevel("INFO", "INFO", os.path.join(__file__, os.pardir, os.pardir, os.pardir, 'logs', 'vCenter.log'))
 
 class DvPortGroupCreator(object):
     def __init__(self, pyvmomi_service, synchronous_task_waiter):
@@ -30,7 +34,7 @@ def create_dv_port_group(self, dv_port_name, dv_switch_name, dv_switch_path, si)
         dv_pg_spec.defaultPortConfig.securityPolicy.inherited = False
 
         task = dv_switch.AddDVPortgroup_Task([dv_pg_spec])
-        print "Successfully created DV Port Group ", dv_port_name
+        logger.info("Successfully created DV Port Group ", dv_port_name)
         port_group = self.synchronous_task_waiter.wait_for_task(task)
 
         return port_group

vCenterShell/commands/VirtualMachinePortGroupConfigurer.py

@@ -1,7 +1,10 @@
 from pyVmomi import vim
 from vCenterShell.pycommon.pyVmomiService import *
 from vCenterShell.pycommon.SynchronousTaskWaiter import SynchronousTaskWaiter
-
+from vCenterShell.pycommon.logger import getLogger
+from vCenterShell.pycommon.logger import configure_loglevel
+logger = getLogger(__name__)
+configure_loglevel("INFO", "INFO", os.path.join(__file__, os.pardir, os.pardir, os.pardir, 'logs', 'vCenter.log'))
 
 class VirtualMachinePortGroupConfigurer(object):
     def __init__(self, pyvmomi_service, synchronous_task_waiter):
@@ -38,5 +41,5 @@ def configure_port_group_on_vm(self, service_instance, virtual_machine_path, vm_
 
         config_spec = vim.vm.ConfigSpec(deviceChange=device_change)
         task = vm.ReconfigVM_Task(config_spec)
-        print "Successfully changed network"
+        logger.info("Successfully changed network")
         return self.synchronous_task_waiter.wait_for_task(task)

vCenterShell/commands/destroyVirtualMachineCommand.py

@@ -10,6 +10,10 @@
 from vCenterShell.pycommon.common_name_utils import generate_unique_name
 from vCenterShell.pycommon.CloudshellDataRetrieverService import *
 from vCenterShell.commands.BaseCommand import BaseCommand
+from vCenterShell.pycommon.logger import getLogger
+from vCenterShell.pycommon.logger import configure_loglevel
+logger = getLogger(__name__)
+configure_loglevel("INFO", "INFO", os.path.join(__file__, os.pardir, os.pardir, os.pardir, 'logs', 'vCenter.log'))
 
 
 class DestroyVirtualMachineCommand(BaseCommand):
@@ -32,7 +36,7 @@ def execute(self):
         vCenter_resource_name = inventory_path_data.vCenter_resource_name
         vm_folder = inventory_path_data.vm_folder
 
-        print "Folder: {0}, vCenter: {1}".format(vm_folder, vCenter_resource_name)
+        logger.info("Folder: {0}, vCenter: {1}".format(vm_folder, vCenter_resource_name))
 
         reservation_id = helpers.get_reservation_context_details().id
         session = helpers.get_api_session()
@@ -41,8 +45,8 @@ def execute(self):
         # get vCenter connection details from vCenter resource
         vCenterConn = self.csRetrieverService.getVCenterConnectionDetails(session, vCenter_details)
 
-        print "Connecting to: {0}, As: {1}, Pwd: {2}".format(vCenterConn["vCenter_url"], vCenterConn["user"],
-                                                             vCenterConn["password"])
+        logger.info("Connecting to: {0}, As: {1}, Pwd: {2}".format(vCenterConn["vCenter_url"], vCenterConn["user"],
+                                                             vCenterConn["password"]))
 
         # connect
         si = self.pvService.connect(vCenterConn["vCenter_url"], vCenterConn["user"], vCenterConn["password"])

vCenterShell/demo/basicFlowDemo.py

@@ -9,7 +9,8 @@
 import vCenterShell.pycommon
 from vCenterShell.pycommon.common_name_utils import generate_unique_name
 from vCenterShell.pycommon.CloudshellDataRetrieverService import *
-
+from vCenterShell.pycommon.logger import getLogger
+logger = getLogger(__name__)
 
 def run(pvService, cloudshellConnectData):
     """
@@ -33,24 +34,24 @@ def run(pvService, cloudshellConnectData):
     template_name = vCenterTemplateAttData["template_name"]
     vCenter_resource_name = vCenterTemplateAttData["vCenter_resource_name"]
     vm_folder = vCenterTemplateAttData["vm_folder"]
-    print "Template: {0}, Folder: {1}, vCenter: {2}".format(template_name,vm_folder,vCenter_resource_name)
+    logger.info("Template: {0}, Folder: {1}, vCenter: {2}".format(template_name,vm_folder,vCenter_resource_name))
 
 
     # get power state of the cloned VM
     power_on = csRetrieverService.getPowerStateAttributeData(resource_att)
-    print "Power On: {0}".format(power_on)
+    logger.info("Power On: {0}".format(power_on))
 
 
     # get cluster and resource pool
     vmClusterAttData = csRetrieverService.getVMClusterAttributeData(resource_att)
     cluster_name = vmClusterAttData["cluster_name"]
     resource_pool = vmClusterAttData["resource_pool"]
-    print "Cluster: {0}, Resource Pool: {1}".format(cluster_name, resource_pool)
+    logger.info("Cluster: {0}, Resource Pool: {1}".format(cluster_name, resource_pool))
 
 
     # get datastore
     datastore_name = csRetrieverService.getVMStorageAttributeData(resource_att)
-    print "Datastore: {0}".format(datastore_name)
+    logger.info("Datastore: {0}".format(datastore_name))
 
 
     reservation_id = helpers.get_reservation_context_details().id
@@ -59,7 +60,7 @@ def run(pvService, cloudshellConnectData):
 
     # get vCenter connection details from vCenter resource
     vCenterConn = csRetrieverService.getVCenterConnectionDetails(session, vCenter_details)
-    print "Connecting to: {0}, As: {1}, Pwd: {2}".format(vCenterConn["vCenter_url"] , vCenterConn["user"], vCenterConn["password"])
+    logger.info("Connecting to: {0}, As: {1}, Pwd: {2}".format(vCenterConn["vCenter_url"] , vCenterConn["user"], vCenterConn["password"]))
 
     # connect
     si = pvService.connect(vCenterConn["vCenter_url"] , vCenterConn["user"], vCenterConn["password"])
@@ -95,7 +96,7 @@ def run(pvService, cloudshellConnectData):
 
 
         sleep_sec = 5
-        print "Sleep for {0} sec".format(sleep_sec)
+        logger.info("Sleep for {0} sec".format(sleep_sec))
         time.sleep( sleep_sec )
 
 
@@ -104,7 +105,7 @@ def run(pvService, cloudshellConnectData):
         helpers.get_api_session().DeleteResource(vm_name)
 
     else:
-        print "template not found"
+        logger.info("template not found")
 
     pvService.disconnect(si)
 

vCenterShell/pycommon/Bootstrapper.py

@@ -1,6 +1,6 @@
 from pyVim.connect import SmartConnect, Disconnect
 from vCenterShell.commands.DeployFromTemplateCommand import DeployFromTemplateCommand
-from vCenterShell.commands.destroyVirtualMachineCommand import DestroyVirtualMachineCommand
+from vCenterShell.commands.DestroyVirtualMachineCommand import DestroyVirtualMachineCommand
 from vCenterShell.pycommon.pyVmomiService import pyVmomiService
 from vCenterShell.commands.CommandExecuterService import CommandExecuterService
 from vCenterShell.commands.NetworkAdaptersRetriever import NetworkAdaptersRetrieverCommand

vCenterShell/pycommon/SynchronousTaskWaiter.py

@@ -1,6 +1,9 @@
-import time
+import time, os
 from pyVmomi import vim, vmodl
-
+from vCenterShell.pycommon.logger import getLogger
+from vCenterShell.pycommon.logger import configure_loglevel
+logger = getLogger(__name__)
+configure_loglevel("INFO", "INFO", os.path.join(__file__, os.pardir, os.pardir, os.pardir, 'logs', 'vCenter.log'))
 
 class SynchronousTaskWaiter(object):
     def __init__(self):
@@ -21,13 +24,13 @@ def wait_for_task(self, task, actionName='job', hideResult=False):
         if task.info.state == vim.TaskInfo.State.success:
             if task.info.result is not None and not hideResult:
                 out = '%s completed successfully, result: %s' % (actionName, task.info.result)
-                print out
+                logger.info(out)
             else:
                 out = '%s completed successfully.' % actionName
-                print out
+                logger.info(out)
         else:
             out = '%s did not complete successfully: %s' % (actionName, task.info.error)
-            print out
+            logger.info(out)
             raise task.info.error
 
         return task.info.result

vCenterShell/pycommon/pyVmomiService.py

@@ -1,9 +1,14 @@
 import requests
 import time
+import os
 
 from datetime import datetime
 from timeit import default_timer as timer
 from pyVmomi import vim
+from vCenterShell.pycommon.logger import getLogger
+from vCenterShell.pycommon.logger import configure_loglevel
+logger = getLogger(__name__)
+configure_loglevel("INFO", "INFO", os.path.join(__file__, os.pardir, os.pardir, os.pardir, 'logs', 'vCenter.log'))
 
 class pyVmomiService:
 
@@ -54,7 +59,7 @@ def connect(self, address, user, password, port=443):
                 si = self.pyvmomi_connect(host=address, user=user, pwd=password, port=port)
             return si
         except IOError as e:
-            print "I/O error({0}): {1}".format(e.errno, e.strerror)
+            logger.info("I/O error({0}): {1}".format(e.errno, e.strerror))
 
     def disconnect(self, si):
         """ Disconnect from vCenter """
@@ -151,7 +156,7 @@ def find_obj_by_path(self, si, path, name, type_name):
         '#searches for the specific vm in the folder'
         res = search_index.FindChild(look_in, name)
 
-        print 'find_obj_by_path took: %s' % (str(datetime.now() - now))
+        logger.info('find_obj_by_path took: %s' % (str(datetime.now() - now)))
         return res
 
     def get_folder(self, si, path):
@@ -202,7 +207,7 @@ def get_folder(self, si, path):
                 child = None
 
         end = timer()
-        print 'get_folder "{0}" took: {1} seconds'.format(path, (str(end - start)))
+        logger.info('get_folder "{0}" took: {1} seconds'.format(path, (str(end - start))))
 
         return sub_folder
 
@@ -235,12 +240,12 @@ def wait_for_task(self, task):
         task_done = False
         while not task_done:
             if task.info.state == 'success':
-                print "Task succeeded: " + task.info.state
+                logger.info("Task succeeded: " + task.info.state)
                 return task.info.result
 
             if task.info.state == 'error':
-                print "error type: %s" % task.info.error.__class__.__name__
-                print "found cause: %s" % task.info.error.faultCause
+                logger.info("error type: %s" % task.info.error.__class__.__name__)
+                logger.info("found cause: %s" % task.info.error.faultCause)
                 task_done = True
                 return None
             time.sleep(1)
@@ -348,7 +353,7 @@ def clone_vm(self, clone_params):
         clone_spec.location = relo_spec
         clone_spec.powerOn = clone_params.power_on
 
-        print "cloning VM..."
+        logger.info("cloning VM...")
 
         task = template.Clone(folder=dest_folder, name=clone_params.vm_name, spec=clone_spec)
         vm = self.wait_for_task(task)
@@ -361,13 +366,13 @@ def destroy_vm(self, vm):
         :param vm: virutal machine pyvmomi object
         """
 
-        print("The current powerState is: {0}. Attempting to power off {1}".format(vm.runtime.powerState, vm.name))
+        logger.info(("The current powerState is: {0}. Attempting to power off {1}".format(vm.runtime.powerState, vm.name)))
 
         task = vm.PowerOffVM_Task()
         self.wait_for_task(task)
 
-        print("{0}".format(task.info.state))
-        print("Destroying VM {0}".format(vm.name))
+        logger.info(("{0}".format(task.info.state)))
+        logger.info(("Destroying VM {0}".format(vm.name)))
 
         task = vm.Destroy_Task()
         return self.wait_for_task(task)