def do_init(self, rwlog_ctx):
self.log.addHandler(
rwlogger.RwLogger(
category="rw-cal-log",
subcategory="aws",
log_hdl=rwlog_ctx,
))
def do_init(self, rwlog_ctx):
if not any(isinstance(h, rwlogger.RwLogger) for h in logger.handlers):
logger.addHandler(
rwlogger.RwLogger(
subcategory="sdnsim",
log_hdl=rwlog_ctx,
))
def _add_root_logger_handling(self):
"""
Create a scheduler hook to set the root logger for this
tasklet on entry. This enables us to capture the logs
used by libraries without having to manually find
the library's logger and set the handler.
"""
root_logger = logging.getLogger()
root_logger.setLevel(logging.DEBUG)
root_rwlog_handler = rwlogger.RwLogger(log_hdl=self._log_hdl, )
# We need to filter this handler by the core CFRunLoop thread id
# so only messages being logged specifically during this tasklets
# scheduler invocation are logged using it's handler.
root_rwlog_handler.addFilter(rwlogger.ThreadFilter.from_current())
def add_root_logger_handler():
""" Set the root logger's handler to this tasklets rwlog handler """
# Clone the current category/subcategory assignment for the tasklet
root_rwlog_handler.set_category(self._rwlog_handler.category)
root_rwlog_handler.set_subcategory(self._rwlog_handler.subcategory)
root_logger.addHandler(root_rwlog_handler)
def remove_root_logger_handler():
""" Remove the root logger's handler to this tasklets rwlog handler """
root_logger.removeHandler(root_rwlog_handler)
self._loop.register_tick_enter_hook(add_root_logger_handler)
self._loop.register_tick_exit_hook(remove_root_logger_handler)
def __init__(self, tasklet_info):
"""
Create a Tasklet object
Tasklets are not directly created by the user, but are created by the
associated Component class via VCS.
@param tasklet_info - info relevant to this tasklet
"""
self._tasklet_info = tasklet_info
self._log = logger_from_tasklet_info(tasklet_info)
self._log.setLevel(logging.DEBUG)
self._log_hdl = tasklet_info.get_rwlog_ctx()
self._rwlog_handler = rwlogger.RwLogger(log_hdl=self._log_hdl)
self._log.addHandler(self._rwlog_handler)
# We want set up the root logger to log to this tasklets rwlog handler
# in order to catch any logs emitted via third party libraries.
# Because of this, we want to ensure that any logs sent to this logger do
# not propogate to the root logger which would cause the messages to get
# logged twice.
self._log.propagate = False
self._loop = StackedEventLoop(self._tasklet_info.rwsched_instance,
self._tasklet_info.rwsched_tasklet,
self._log)
self._add_root_logger_handling()
def do_instance_alloc(self, component_handle, tasklet_info, instance_url):
"""This function is called for each new instance of the tasklet.
The tasklet specific information such as scheduler instance,
trace context, logging context are passed in 'tasklet_info' variable.
This function stores the tasklet information locally.
"""
logger.debug("RwdtstaskletPython: do_instance_alloc function called")
self.taskletinfo = tasklet_info
# Save the scheduler instance and tasklet instance objects
#self.rwsched = tasklet_info.rwsched_instance
#self.tasklet = tasklet_info.rwsched_tasklet_info
#self.rwlog_instance = tasklet_info.rwlog_instance
tasklet_logger = rwlogger.RwLogger(subcategory="rw-vcs",
log_hdl=self.taskletinfo.rwlog_ctx)
logger.addHandler(tasklet_logger)
# After this point, all logger calls will log events to rw_vcs using
# the tasklets rwlog handle
logger.debug("Added rwlogger handler to tasklet logger")
instance_handle = RwTaskletPlugin.InstanceHandle()
return instance_handle
def do_init(self, rwlog_ctx):
if not any(isinstance(h, rwlogger.RwLogger) for h in logger.handlers):
logger.addHandler(
rwlogger.RwLogger(
category="rw-cal-log",
subcategory="cloudsim",
log_hdl=rwlog_ctx,
))
def do_init(self, rwlog_ctx):
if not any(isinstance(h, rwlogger.RwLogger) for h in logger.handlers):
logger.addHandler(
rwlogger.RwLogger(
category="rw-cal-log",
subcategory="openmano_vimconnector",
log_hdl=rwlog_ctx,
))
def do_init(self, rwlog_ctx):
self._rwlog_handler = rwlogger.RwLogger(category="rw-cal-log",
subcategory="kubernetes",
log_hdl=rwlog_ctx,)
self.log.addHandler(self._rwlog_handler)
self.log.propagate = False
self.auth_url = account.kubernetes.auth_url
def do_init(self, rwlog_ctx):
if not any(isinstance(h, rwlogger.RwLogger) for h in logger.handlers):
logger.addHandler(
rwlogger.RwLogger(
category="rw-monitor-log",
subcategory="ceilometer",
log_hdl=rwlog_ctx,
))
def do_init(self, rwlog_ctx):
self._rwlog_handler = rwlogger.RwLogger(
category="rw-cal-log",
subcategory="openstack",
log_hdl=rwlog_ctx,
)
self.log.addHandler(self._rwlog_handler)
self.log.propagate = False
def do_init(self, rwlog_ctx):
logger.addHandler(
rwlogger.RwLogger(
category="rw-cal-log",
subcategory="cloudsimproxy",
log_hdl=rwlog_ctx,
)
)
def do_init(self, rwlog_ctx):
if not any(isinstance(h, rwlogger.RwLogger) for h in logger.handlers):
logger.addHandler(
rwlogger.RwLogger(
category="rw-cal-log",
subcategory="rwcal.mock",
log_hdl=rwlog_ctx,
))
account = RwcalYang.CloudAccount()
account.name = 'mock_account'
account.account_type = 'mock'
account.mock.username = '******'
self.create_default_resources(account)
def do_init(self, rwlog_ctx):
if not any(isinstance(h, rwlogger.RwLogger) for h in logger.handlers):
logger.addHandler(
rwlogger.RwLogger(
subcategory="rwsdn.mock",
log_hdl=rwlog_ctx,
))
account = RwsdnYang.SDNAccount()
account.name = 'mock'
account.account_type = 'mock'
account.mock.username = '******'
self.datastore = DataStore()
self.topology = self.datastore.create_default_topology()
def do_init(self, rwlog_ctx):
providers = {
"sdnsim": rift.sdn.SdnSim,
"mock": rift.sdn.Mock,
}
logger.addHandler(
rwlogger.RwLogger(
subcategory="rwsdn",
log_hdl=rwlog_ctx,
))
self._impl = {}
for name, impl in providers.items():
try:
self._impl[name] = impl()
except Exception:
msg = "unable to load SDN implementation for {}"
logger.exception(msg.format(name))
def setUp(self):
self.rwlogger = rwlogger.RwLogger(subcategory="rw-appmgr-log") # default cat
self.logger = logging.getLogger(__name__)
self.logger.addHandler(self.rwlogger)
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import rift.rwcal.aws as aws_drv
import logging
import argparse
import rwlogger
import sys, os, time
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger()
rwlog_handler = rwlogger.RwLogger(
category="rw-cal-log",
subcategory="aws",
)
logger.addHandler(rwlog_handler)
#logger.setLevel(logging.DEBUG)
def prepare_vm_after_boot(drv, argument):
vm_inst = drv.get_instance(argument.server_id)
logger.info("Waiting for VM instance to get to running state")
vm_inst.wait_until_running()
logger.info("VM instance is now in running state")
if argument.vdu_name:
vm_inst.create_tags(Tags=[{'Key': 'Name', 'Value': argument.vdu_name}])
if argument.vdu_node_id is not None:
vm_inst.create_tags(Tags=[{
gi.require_version('RwNetns', '1.0')
gi.require_version('RwNetnsLogYang', '1.0')
from gi.repository import RwNetns
import six
# Usually, just importing RwNetnsLogYang would be sufficient, but since
# some of these classes are only used in error paths, I want to
# make sure all names are resolved up front.
from gi.repository.RwNetnsLogYang import (
EnteringNetns, ExitingNetns, MissingResolvConf, MountingResolvConf,
MountingResolvConfFailed, UnmountingResolvConf, UnmountingResolvConfFailed,
MultipleNetnsError, ChangeNetnsFailed, ChangeNetnsFdFailed,
GetNetnsFdFailed)
rwlogger = rwlogger.RwLogger(subcategory="rw-netns") # need better category?
logger = logging.getLogger(__name__)
logger.addHandler(rwlogger)
class NetworkNamespaceException(Exception):
pass
class NetnsEnvironment(object):
current_netns = None
def __init__(self, netns_name, bind_resolv_conf=True):
if not isinstance(netns_name, six.string_types):
raise TypeError("netns is expected to be a string: %s", netns_name)
# limitations under the License.
#
import rift.rwcal.openstack as openstack_drv
import logging
import argparse
import sys, os, time
import rwlogger
import yaml
import random
import fcntl
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger()
rwlog_handler = rwlogger.RwLogger(
category="rw-cal-log",
subcategory="openstack",
)
logger.addHandler(rwlog_handler)
#logger.setLevel(logging.DEBUG)
class FileLock:
FILE_LOCK = '/tmp/_openstack_prepare_vm.lock'
def __init__(self):
# This will create it if it does not exist already
self.filename = FileLock.FILE_LOCK
self.handle = None
# Bitwise OR fcntl.LOCK_NB if you need a non-blocking lock
def acquire(self):
