def showException(title):
error = sys.exc_info()[1]
if isinstance(error, Throwable):
Logger.getLogger("jython").log(Level.WARNING, title, error)
ExceptionDetailsErrorDialog.openError(None, title, wisdom(), error)
else:
error = str(error)
Logger.getLogger("jython").log(Level.WARNING, "%s: %s\n%s" % (title, error, traceback.format_exc()))
MessageDialog.openWarning(None, title, "%s\n\n\n%s" % (wisdom(), error))
def __init__(self, logger_name, resource_bundle_name='oracle.weblogic.deploy.messages.wlsdeploy_rb'):
self.name = logger_name
self.resource_bundle_name = resource_bundle_name
if resource_bundle_name is not None:
self.logger = JLogger.getLogger(logger_name, resource_bundle_name)
else:
self.logger = JLogger.getLogger(logger_name)
return
def __init__(self,
logger_name,
resource_bundle_name=TestingConstants.RESOURCE_BUNDLE_NAME):
self.name = logger_name
self.resource_bundle_name = resource_bundle_name
if resource_bundle_name is not None:
self.logger = JLogger.getLogger(logger_name, resource_bundle_name)
else:
self.logger = JLogger.getLogger(logger_name)
return
def showException(title):
error = sys.exc_info()[1]
if isinstance(error, Throwable):
Logger.getLogger("jython").log(Level.WARNING, title, error)
ExceptionDetailsErrorDialog.openError(None, title, wisdom(), error)
else:
error = str(error)
Logger.getLogger("jython").log(
Level.WARNING,
"%s: %s\n%s" % (title, error, traceback.format_exc()))
MessageDialog.openWarning(None, title,
"%s\n\n\n%s" % (wisdom(), error))
def main():
printlog("main: hello from python\n")
LogManager.getLogManager().getLogger(Logger.GLOBAL_LOGGER_NAME).setLevel(Level.FINE)
logger = Logger.getLogger(Logger.GLOBAL_LOGGER_NAME)
logger.info("Test.")
printlog("main: bye from python\n")
def log_results(self, logger):
"""
:param logger:
:return:
"""
_method_name = 'log_results'
if logger is not None:
# Get counts for all the TestResult objects
# in this TestResults object
results_summary = self.__get_summary()
jlogger = JLogger.getLogger(logger.get_name(), logger.resource_bundle_name)
jlogger.setLevel(JLevel.INFO)
# Determine what the severity level is going to be for the
# summary log message. Needs to be set in accordance with
# what the severest test message was.
if results_summary[TestResults._INFOS_COUNT] > 0:
jlogger.setLevel(JLevel.INFO)
if results_summary[TestResults._WARNINGS_COUNT] > 0:
jlogger.setLevel(JLevel.WARNING)
if results_summary[TestResults._ERRORS_COUNT] > 0:
jlogger.setLevel(JLevel.SEVERE)
total_messages_count = \
int(results_summary[TestResults._ERRORS_COUNT]) + int(results_summary[TestResults._WARNINGS_COUNT]) + \
int(results_summary[TestResults._INFOS_COUNT])
logger.log(jlogger.getLevel(),
'WLSDPLY-09810',
results_summary[TestResults._ERRORS_COUNT],
results_summary[TestResults._WARNINGS_COUNT],
results_summary[TestResults._INFOS_COUNT],
class_name=self._class_name, method_name=_method_name)
if total_messages_count > 0:
logger.log(jlogger.getLevel(), 'WLSDPLY-09811', total_messages_count,
class_name=self._class_name, method_name=_method_name)
for test_result in self._test_result_dict.values():
if test_result.get_infos_count() > 0:
jlogger.setLevel(JLevel.INFO)
self.__log_results_category_details(test_result.get_infos_messages(), _method_name, jlogger)
for test_result in self._test_result_dict.values():
if test_result.get_warnings_count() > 0:
jlogger.setLevel(JLevel.WARNING)
self.__log_results_category_details(test_result.get_warnings_messages(), _method_name, jlogger)
for test_result in self._test_result_dict.values():
if test_result.get_errors_count() > 0:
jlogger.setLevel(JLevel.SEVERE)
self.__log_results_category_details(test_result.get_errors_messages(), _method_name, jlogger)
jlogger.setLevel(JLevel.INFO)
return
def __init__(self):
self._log = Logger.getLogger(VLAB.LOGGER_NAME)
self._reqElemFac = VLabRequestElementFactory()
self._defaultFactory = DefaultRequestElementFactory.getInstance()
self._requestFile = File('')
self.pmap = {}
me=self.__class__.__name__ +'::'+VLAB.me()
self._log.info(me + ": constructor completed...")
def _createConn(self):
try:
System.setProperty("com.couchbase.forceIPv4", "false")
logger = Logger.getLogger("com.couchbase.client")
logger.setLevel(Level.SEVERE)
for h in logger.getParent().getHandlers():
if isinstance(h, ConsoleHandler):
h.setLevel(Level.SEVERE)
# self.cluster = CouchbaseCluster.create(Java_Connection.env, self.hosts)
self.cluster = CouchbaseCluster.fromConnectionString(
Java_Connection.env, self.connection_string)
self.cluster.authenticate("Administrator", self.password)
self.cb = self.cluster.openBucket(self.bucket)
except CouchbaseException:
self.cluster.disconnect()
raise
class Log(object):
prefix = ""
logger = Logger.getLogger("DynMods")
@staticmethod
def info(*text):
Log.logger.log(Level.INFO, Log.prefix + " ".join(map(unicode, text)))
@staticmethod
def severe(*text):
Log.logger.log(Level.SEVERE, Log.prefix + " ".join(map(unicode, text)))
@staticmethod
def msg(player, *text):
player.addChatMessage(
minecraft.util.text.TextComponentString(
Log.prefix + " ".join(map(unicode, text))))
def __init__(self, id, name, descr):
JQuest.__init__(self, id, name, descr)
# All of these are overridden in the subclasses
self.NPC = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
self.Items = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
self.Mob = [0, 1, 2]
self.classid = 0
self.prevclass = 0
self.qn = "SagasSuperclass"
self.X = [0, 1, 2]
self.Y = [0, 1, 2]
self.Z = [0, 1, 2]
self.Text = [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17
]
self.Spawn_List = {}
_log = Logger.getLogger("SagasSuperclass")
def connectCluster(self, username=None, password=None):
if username:
self.username = username
if password:
self.password = password
try:
System.setProperty("com.couchbase.forceIPv4", "false")
logger = Logger.getLogger("com.couchbase.client")
logger.setLevel(Level.SEVERE)
for h in logger.getParent().getHandlers():
if isinstance(h, ConsoleHandler):
h.setLevel(Level.SEVERE)
self.cluster = CouchbaseCluster.create(env, self.server.ip)
self.cluster.authenticate(self.username, self.password)
self.clusterManager = self.cluster.clusterManager()
except CouchbaseException:
print "cannot login from user: %s/%s" % (self.username,
self.password)
raise
def _createConn(self):
try:
self.log.debug("Creating cluster connection")
System.setProperty("com.couchbase.forceIPv4", "false")
logger = Logger.getLogger("com.couchbase.client")
logger.setLevel(Level.SEVERE)
for h in logger.getParent().getHandlers():
if isinstance(h, ConsoleHandler):
h.setLevel(Level.SEVERE)
cluster_env = ClusterEnvironment \
.builder(", ".join(self.hosts).replace(" ", ""),
self.username, self.password) \
.timeoutConfig(TimeoutConfig.builder()
.connectTimeout(Duration.ofSeconds(20))
.kvTimeout(Duration.ofSeconds(10)))
self.cluster = Cluster.connect(cluster_env.build())
self.bucketObj = self.cluster.bucket(self.bucket)
self.collection = self.bucketObj.defaultCollection()
except Exception as e:
raise Exception("SDK Connection error: " + str(e))
def connectCluster(self, username=None, password=None):
if username:
self.username = username
if password:
self.password = password
try:
logger = Logger.getLogger("com.couchbase.client")
logger.setLevel(Level.SEVERE)
# fh = FileHandler("java_client.log");
# logger.addHandler(fh);
for h in logger.getParent().getHandlers():
if isinstance(h, ConsoleHandler):
h.setLevel(Level.SEVERE)
self.cluster = CouchbaseCluster.create(env, self.ip)
self.cluster.authenticate(self.username, self.password)
self.clusterManager = self.cluster.clusterManager()
except CouchbaseException:
print "cannot login from user: %s/%s" % (self.username,
self.password)
raise
def connectCluster(self, username=None, password=None):
if username:
self.username = username
if password:
self.password = password
try:
System.setProperty("com.couchbase.forceIPv4", "false")
logger = Logger.getLogger("com.couchbase.client")
logger.setLevel(Level.SEVERE)
for h in logger.getParent().getHandlers():
if isinstance(h, ConsoleHandler):
h.setLevel(Level.SEVERE)
self.cluster = Cluster.connect(
ClusterEnvironment.builder(
",".join(self.server.ip), self.username,
self.password).timeoutConfig(
TimeoutConfig.builder().kvTimeout(
Duration.ofSeconds(10))).build())
except CouchbaseException:
print "cannot login from user: %s/%s" % (self.username,
self.password)
raise
"""
api.py
Provides utility defs and classes to assist in scripting for the OpenRS emulator.
Authors: Blake Beaupain
"""
from java.util.logging import Logger
# Initialize the script logger.
log = Logger.getLogger("OpenRS:Script")
# TODO: Initialize any defs/classes for the scripting system.
def __init__(self):
from java.util.logging import Logger
self.logger = Logger.getLogger('jython.hotel')
def log(self, m): l = Logger.getLogger(self.qn) l.info(m)
import jarray
from java.util.logging import Logger
from javax.management import ObjectName
from sets import Set
import PbCommon
from com.muse.fmw.platform import PbProperties
from entities.PbWlstEntity import PbWlstEntity
from pb import PbWlstWrappers
from WlstWrapper import assign, getMachineNames, pushd, \
removeReferencesToBean, getMBean, destroyMachine
# from pb import PbTypes
LOGGER = Logger.getLogger("entities.PbWlstEntities")
__clusterToServersMap = dict()
def assignServersToClusters(clusterToServersMap):
LOGGER.info("About to assign servers to clusters")
clusters = clusterToServersMap.keys()
for cluster in clusters:
serversSet = clusterToServersMap.get(cluster)
serverCsv = PbCommon.getCsv(serversSet)
LOGGER.info("Assigning to cluster " + cluster +
" the following servers: " + serverCsv)
assign("Server", serverCsv, "Cluster", cluster)
def getEntityCollection(func, prefix):
result = Set()
This module contains utility functions for use within Jython unit tests written
for Aqua JSystem. They allow logging and access to various jsystem components
(sut, system objects, etc.).
"""
import unittest
from java.util.logging import Logger
from jsystem.framework.system import SystemManagerImpl
from jsystem.framework.report import ListenerstManager
from jsystem.framework.sut import SutFactory
from jsystem.framework.monitor import MonitorsManager
from jsystem.framework import RunProperties
from jsystem.framework.fixture import RootFixture
log = Logger.getLogger("Jython")
report = ListenerstManager.getInstance()
system = SystemManagerImpl.getInstance()
sut = SutFactory.getInstance().getSutInstance()
monitors = MonitorsManager.getInstance()
runProperties = RunProperties.getInstance()
class Parameter(object):
pass
class SystemTestCase(unittest.TestCase):
__fixture__ = RootFixture
__tearDownFixture__ = RootFixture
__parameters__ = dict()
def __init__(self, name):
unittest.TestCase.__init__(self, name)
def info(self, message):
Logger.getLogger(self.qn).info(message)
# Select the ipipe scripts based on the observation mode
from herschel.pacs.spg.pipeline import SelectPacsPipeline
from herschel.pacs.signal import SlicedFrames
from herschel.pacs.signal.context import PacsContext
from herschel.pacs.spg.common import PacsPropagateMetaKeywordsTask
from herschel.pacs.spg.pipeline.ProductSinkHandling import *
from herschel.pacs.spg.pipeline.spg_spec_tools import *
from herschel.ia.pal import *
from herschel.pacs.cal import *
from herschel.pacs.cal import GetPacsCalDataTask
from herschel.ia.obs import ObservationContext
from herschel.ia.numeric.toolbox.basic import *
from herschel.pacs.spg.common.util import PacsProcessingExceptionHandler
from java.lang import Throwable
_logger = Logger.getLogger("pacsspectro_pipeline")
# Cameras to reduce
try:
cameraList
except NameError:
cameraList = ['red','blue']
# Check that we have data for all camera's
for camera in list(cameraList):
if obs.level0.getCamera(camera).available == False:
_logger.warning("There is no level 0 data for camera: "+camera)
cameraList.remove(camera)
maxErrors = len(cameraList)
if maxErrors == 0:
# You should have received a copy of the GNU Lesser General
# Public License along with HCSS.
# If not, see <http://www.gnu.org/licenses/>.
#
# Some tools used in several spectrometer SPG scripts
#
# Author: Jeroen de Jong
#
from java.util.logging import Logger, Level
from herschel.ia.pal import ListContext
from herschel.pacs.signal import ProductUtil
from herschel.pacs.spg.common.util import PacsProcessingException
from herschel.pacs.signal import RangeDescription
LOGGER = Logger.getLogger("herschel.pacs.spg.pipeline.spg_spec_tools")
# Computes the average ra/dec from the rebinned cubes of a level-2 product
# and puts this into the observation context meta data
def extractRaDecToObs(obs):
context = obs.level2
subcontext = ListContext()
# for camera in ['red', 'blue']:
for camera in ['red']:
rcube = context.getCamera(camera).rcube
if rcube.available:
subcontext.refs.add(rcube.productRef)
# tamanio = subcontext.getAllRefs().size()
# You should have received a copy of the GNU Lesser General
# Public License along with HCSS.
# If not, see <http://www.gnu.org/licenses/>.
#
# Some tools used in several spectrometer SPG scripts
#
# Author: Jeroen de Jong
#
from java.util.logging import Logger, Level
from herschel.ia.pal import ListContext
from herschel.pacs.signal import ProductUtil
from herschel.pacs.spg.common.util import PacsProcessingException
from herschel.pacs.signal import RangeDescription
LOGGER = Logger.getLogger("herschel.pacs.spg.pipeline.spg_spec_tools")
# Computes the average ra/dec from the rebinned cubes of a level-2 product
# and puts this into the observation context meta data
def extractRaDecToObs(obs):
context = obs.level2
subcontext = ListContext()
# for camera in ['red', 'blue']:
for camera in ['red']:
rcube = context.getCamera(camera).rcube
if rcube.available:
subcontext.refs.add(rcube.productRef)
# tamanio = subcontext.getAllRefs().size()
if __name__ == '__main__':
from wlstModule import * # @UnusedWildImport
from java.util.logging import Logger
from WlstWrapper import pushd, pwd, popd, lsChildMap, lsmap
LOGGER = Logger.getLogger("pb.Catalogue")
class CatalogueEntry:
def __init__(self, name, dir, dirContents=None):
self.name = name
self.dir = dir
self.branches = dict()
self.dirContents = dirContents
def catalogueEntryToString(self, entry):
result = entry.dir + "\n"
for child in entry.branches.values():
result = result + self.catalogueEntryToString(child)
return result
def __str__(self):
return self.catalogueEntryToString(self)
def catalogueTree(catalogueEntry):
try:
origDir = catalogueEntry.dir
theContents = catalogueEntry.dirContents
/**
* Helper function that puts the calling thread to sleep for a desired
* number of seconds.
*
* @param className is the calling getClass().getName() if an exception
* needs to get thrown.
* @param seconds is the number of seconds to sleep
*/
public static int sleepSeconds( String className, int seconds )
{
if ( seconds < 1 ) { seconds = 1; }
try {
Thread.sleep( 1000 * seconds );
} catch (InterruptedException ex) {
Logger.getLogger(className).log(Level.SEVERE, null, ex);
}
return 0;
}
/**
* Waits on all started threads to shutdown, closes down the input
*/
public void waitToShutdown()
{
try {
for( Elevator elevator: elevatorList ) {
elevator.getThread().join();
parser.stop();
}
This module contains utility functions for use within Jython unit tests written
for Aqua JSystem. They allow logging and access to various jsystem components
(sut, system objects, etc.).
"""
import unittest
from java.util.logging import Logger
from jsystem.framework.system import SystemManagerImpl
from jsystem.framework.report import ListenerstManager
from jsystem.framework.sut import SutFactory
from jsystem.framework.monitor import MonitorsManager
from jsystem.framework import RunProperties
from jsystem.framework.fixture import RootFixture
log = Logger.getLogger("Jython")
report = ListenerstManager.getInstance()
system = SystemManagerImpl.getInstance()
sut = SutFactory.getInstance().getSutInstance()
monitors = MonitorsManager.getInstance()
runProperties = RunProperties.getInstance()
class Parameter(object):
pass
class SystemTestCase(unittest.TestCase):
__fixture__ = RootFixture
__tearDownFixture__ = RootFixture
__parameters__ = dict()
from edu.cmu.sphinx.linguist.flat import FlatLinguist
from edu.cmu.sphinx.recognizer import Recognizer
from edu.cmu.sphinx.util import LogMath
from java.util.logging import Logger
from java.util.logging import Level
from java.net import URL
from java.util import ArrayList
# if (args.length < 1) {
# throw new Error("USAGE: GroovyTranscriber <sphinx4 root> [<WAV file>]")
# }
root = "../../.."
# init common
Logger.getLogger("").setLevel(Level.WARNING)
logMath = LogMath(1.0001, true)
absoluteBeamWidth = -1
relativeBeamWidth = 1E-80
wordInsertionProbability = 1E-36
languageWeight = 8.0
# init audio data
audioSource = AudioFileDataSource(3200, None)
audioURL = URL(
"file:" + root +
"/src/apps/edu/cmu/sphinx/demo/transcriber/10001-90210-01803.wav")
# (args.length > 1) ?
# File(args[0]).toURI().toURL() :
audioSource.setAudioFile(audioURL, None)
'''
api.py
Provides utility defs and classes to assist in scripting for the OpenRS emulator.
Authors: Blake Beaupain
'''
from java.util.logging import Logger
# Initialize the script logger.
log = Logger.getLogger('OpenRS:Script')
# TODO: Initialize any defs/classes for the scripting system.
from java.util.logging import Logger
import Catalogue
import PbCommon
from com.muse.fmw.platform import PbProperties
from entities.EntityUtils import ConfigurableCollection
import entities.EntityUtils as eu
from wlst.WlstWrapper import connect, cd, getMBean, setCluster, assign
LOGGER = Logger.getLogger("PbWlstLib")
global connected
connected = False
requiresRestart = False
global props
def conectToAdminServerOnAnyUrl(connectionUrls, userName, password) :
connected = False
for connectionUrl in connectionUrls :
try :
LOGGER.info("Trying to connect to " + connectionUrl)
connect(userName, password, connectionUrl)
connected = True
LOGGER.info("Connected to " + connectionUrl)
break
except:
LOGGER.info("Failed to connect as: " + str(userName) + " to " + str(connectionUrl))
def test_volume(self):
nodes_in_cluster = [self.servers[0]]
print "Start Time: %s" % str(
time.strftime("%H:%M:%S", time.gmtime(time.time())))
#######################################################################
self.log.info("Step 1: Add a N1QL/Index nodes")
self.query_node = self.servers[1]
rest = RestConnection(self.query_node)
rest.set_data_path(data_path=self.query_node.data_path,
index_path=self.query_node.index_path,
cbas_path=self.query_node.cbas_path)
result = self.add_node(self.query_node, rebalance=False)
self.assertTrue(result, msg="Failed to add N1QL/Index node.")
self.log.info("Step 2: Add a KV nodes")
result = self.add_node(self.servers[2],
services=["kv"],
rebalance=True)
self.assertTrue(result, msg="Failed to add KV node.")
nodes_in_cluster = nodes_in_cluster + [
self.servers[1], self.servers[2]
]
#######################################################################
self.log.info("Step 3: Create Couchbase buckets.")
self.create_required_buckets()
#######################################################################
env = DefaultCouchbaseEnvironment.builder().mutationTokensEnabled(
True).computationPoolSize(5).socketConnectTimeout(
10000000).connectTimeout(10000000).maxRequestLifetime(
TimeUnit.SECONDS.toMillis(1200)).build()
try:
System.setProperty("com.couchbase.forceIPv4", "false")
logger = Logger.getLogger("com.couchbase.client")
logger.setLevel(Level.SEVERE)
for h in logger.getParent().getHandlers():
if isinstance(h, ConsoleHandler):
h.setLevel(Level.SEVERE)
cluster = CouchbaseCluster.create(env, self.master.ip)
cluster.authenticate("Administrator", "password")
self.bucket = cluster.openBucket("GleambookUsers")
self.msg_bucket = cluster.openBucket("GleambookMessages")
except CouchbaseException:
print "cannot login from user: %s/%s" % (self.username,
self.password)
raise
self.c = cluster
self.items_start_from = 0
self.total_num_items = self.input.param("num_items", 5000)
self.load_data()
self.sleep(20, "Sleeping after 4th step.")
self.validate_items_count()
self.log.info("Step 4: Add node")
result = self.add_node(self.servers[3], rebalance=False)
self.assertTrue(result, msg="Failed to add node.")
self.log.info("Step 5: Loading %s items" % self.total_num_items)
self.load_data()
self.log.info("Step 6: Rebalance Cluster")
rebalance = self.rebalance()
reached = RestHelper(self.rest).rebalance_reached(wait_step=120)
self.assertTrue(reached, "rebalance failed, stuck or did not complete")
nodes_in_cluster = nodes_in_cluster + [self.servers[3]]
self.log.info("Step 7: Start Verification")
self.validate_items_count()
self.check_snap_start_corruption()
#######################################################################
self.sleep(20)
self.log.info("Step 8: Delete/Update docs.")
self.update_data()
self.log.info("Step 9: Verifying Data")
self.validate_items_count()
self.check_snap_start_corruption()
#######################################################################
self.log.info("Step 10: Removing node and Rebalance cluster")
rebalance = self.cluster.async_rebalance(nodes_in_cluster, [],
[self.servers[3]])
nodes_in_cluster.remove(self.servers[3])
self.log.info("Step 11: Loading %s items" % self.total_num_items)
self.load_data()
rebalance.get_result()
reached = RestHelper(self.rest).rebalance_reached(wait_step=120)
self.assertTrue(reached, "rebalance failed, stuck or did not complete")
self.log.info("Step 12: Verifying Data")
self.validate_items_count()
self.check_snap_start_corruption()
#######################################################################
self.sleep(20)
self.log.info("Step 13: Delete/Update docs.")
self.update_data()
self.log.info("Step 14: Verifying Data")
self.validate_items_count()
self.check_snap_start_corruption()
#######################################################################
self.sleep(20)
self.log.info("Step 15: Add node")
result = self.add_node(self.servers[3], rebalance=False)
nodes_in_cluster = nodes_in_cluster + [self.servers[3]]
self.log.info("Step 16: Loading %s items" % self.total_num_items)
self.load_data()
self.log.info("Step 17: Rebalancing Cluster")
rebalance = self.cluster.async_rebalance(nodes_in_cluster, [],
[self.servers[2]])
rebalance.get_result()
reached = RestHelper(self.rest).rebalance_reached(wait_step=120)
self.assertTrue(reached, "rebalance failed, stuck or did not complete")
nodes_in_cluster.remove(self.servers[2])
self.log.info("Step 18: Verifying Data")
self.validate_items_count()
self.check_snap_start_corruption()
#######################################################################
self.sleep(20)
self.log.info("Step 19: Delete/Update docs.")
self.update_data()
self.log.info("Step 20: Verifying Data")
self.validate_items_count()
self.check_snap_start_corruption()
#######################################################################
self.sleep(20)
self.log.info("Step 21: Add node")
result = self.add_node(self.servers[2], rebalance=False)
self.log.info("Step 22: Loading %s items" % self.total_num_items)
self.load_data()
self.log.info("Step 23: Rebalancing Cluster")
rebalance = self.rebalance()
reached = RestHelper(self.rest).rebalance_reached(wait_step=120)
self.assertTrue(reached, "rebalance failed, stuck or did not complete")
nodes_in_cluster = nodes_in_cluster + [self.servers[2]]
self.log.info("Step 24: Verifying Data")
self.validate_items_count()
self.check_snap_start_corruption()
#######################################################################
self.sleep(20)
self.log.info("Step 25: Delete/Update docs.")
self.update_data()
self.log.info("Step 26: Verifying Data")
self.validate_items_count()
self.check_snap_start_corruption()
#######################################################################
self.sleep(20)
self.log.info("Step 27: Add node")
result = self.add_node(self.servers[4], rebalance=False)
self.log.info("Step 28: Loading %s items" % self.total_num_items)
self.load_data()
self.log.info("Step 29: Rebalancing Cluster")
rebalance = self.rebalance()
nodes_in_cluster = nodes_in_cluster + [self.servers[4]]
reached = RestHelper(self.rest).rebalance_reached(wait_step=120)
self.assertTrue(reached, "rebalance failed, stuck or did not complete")
self.log.info("Step 30: Verifying Data")
self.validate_items_count()
self.check_snap_start_corruption()
#######################################################################
self.sleep(20)
self.log.info("Step 31: Delete/Update docs.")
self.update_data()
self.log.info("Step 32: Verifying Data")
self.validate_items_count()
self.check_snap_start_corruption()
#######################################################################
self.sleep(20)
self.log.info("Step 33: Removing node, Rebalancing Cluster")
rebalance = self.cluster.async_rebalance(nodes_in_cluster, [],
[self.servers[3]])
nodes_in_cluster.remove(self.servers[3])
self.log.info("Step 34: Loading %s items" % self.total_num_items)
self.load_data()
rebalance.get_result()
reached = RestHelper(self.rest).rebalance_reached(wait_step=120)
self.assertTrue(reached, "rebalance failed, stuck or did not complete")
self.log.info("Step 35: Verifying Data")
self.validate_items_count()
self.check_snap_start_corruption()
#######################################################################
self.sleep(20)
self.log.info("Step 36: Adding 3 nodes")
otp1 = self.add_node(self.servers[5], rebalance=False)
otp2 = self.add_node(self.servers[6], rebalance=False)
otp3 = self.add_node(self.servers[7], rebalance=False)
self.log.info("Step 37: Loading %s items" % self.total_num_items)
self.load_data()
self.log.info("Step 38: Rebalancing Cluster")
rebalance = self.rebalance()
nodes_in_cluster = nodes_in_cluster + [
self.servers[5], self.servers[6], self.servers[7]
]
reached = RestHelper(self.rest).rebalance_reached(wait_step=120)
self.assertTrue(reached, "rebalance failed, stuck or did not complete")
self.log.info("Step 39: Verifying Data")
self.validate_items_count()
self.check_snap_start_corruption()
#######################################################################
self.log.info("Step 40: Graceful failover node")
self.rest.fail_over(otp3.id, graceful=True)
self.log.info("Step 41: Loading %s items" % self.total_num_items)
self.load_data()
self.sleep(10)
reached = RestHelper(self.rest).rebalance_reached(wait_step=120)
self.assertTrue(reached, "rebalance failed, stuck or did not complete")
self.log.info("Step 42: Rebalancing Cluster")
rebalance = self.rebalance()
nodes_in_cluster.remove(self.servers[7])
reached = RestHelper(self.rest).rebalance_reached(wait_step=120)
self.assertTrue(reached, "rebalance failed, stuck or did not complete")
#######################################################################
self.log.info("Step 43: Adding node and rebalancing")
otp3 = self.add_node(self.servers[7], rebalance=True)
nodes_in_cluster = nodes_in_cluster + [self.servers[7]]
#######################################################################
self.log.info("Step 44: Graceful failover node")
self.rest.fail_over(otp3.id, graceful=True)
self.log.info("Step 41: Loading %s items" % self.total_num_items)
self.load_data()
self.sleep(10)
reached = RestHelper(self.rest).rebalance_reached(wait_step=120)
self.assertTrue(reached, "rebalance failed, stuck or did not complete")
self.log.info("Step 45: Delta recover node")
self.rest.set_recovery_type(otp3.id, "delta")
self.log.info("Step 46: Add node back to cluster")
self.rest.add_back_node(otp3.id)
rebalance = self.rebalance()
reached = RestHelper(self.rest).rebalance_reached(wait_step=120)
self.assertTrue(reached, "rebalance failed, stuck or did not complete")
self.log.info("Step 47: Graceful failover node")
self.rest.fail_over(otp2.id, graceful=True)
self.log.info("Step 48: Loading %s items" % self.total_num_items)
self.load_data()
self.sleep(10)
reached = RestHelper(self.rest).rebalance_reached(wait_step=120)
self.assertTrue(reached, "rebalance failed, stuck or did not complete")
self.log.info("Step 49: Delta recover node")
self.rest.set_recovery_type(otp2.id, "full")
self.log.info("Step 50: Add node back to cluster")
self.rest.add_back_node(otp2.id)
rebalance = self.rebalance()
reached = RestHelper(self.rest).rebalance_reached(wait_step=120)
self.assertTrue(reached, "rebalance failed, stuck or did not complete")
self.bucket.close()
self.msg_bucket.close()
cluster.disconnect()
from wlstModule import * # @UnusedWildImport
import jarray
from java.lang import String
from java.util.logging import *
from java.util.logging import Logger
from javax.management import ObjectName
import sys
import traceback
import PlatformBuildBase as pbb
from pb import PbWlstLib as pbwl
from pb import SystemControl
from weblogic.management.scripting.utils.wlst import *
LOGGER = Logger.getLogger("ApplyDomainHAConfig")
domainHome = pbb.properties.get("domainHome")
# Prime PbWLstLib with properties
pbwl.props = pbb.properties
global online
online = False
LOGGER = Logger.getLogger("CompleteDomain")
def connect():
global online
if (online):
from wlstModule import * # @UnusedWildImport
from WlstWrapper import connect
from com.muse.properties.secure import EncryptionUtils
from java.io import FileInputStream
from java.lang import System
from java.util.logging import Logger
import getopt
import os
import sys
global connected
connected = False
global LOGGER
LOGGER = Logger.getLogger("CreateCredMap")
def usage():
print "Usage:"
print "ConfigureDomain.py -t <domainDir> -p <properties> -d <domain>"
def getDecryptedValue(props, key):
ENCRPYTED_VALUE_PREFIX = "::ENCRYPTED::"
password = props.get(key)
if password:
passkey = props.get('security.passkey')
if password.startswith(ENCRPYTED_VALUE_PREFIX):
password = EncryptionUtils.decryptString(passkey, password[len(ENCRPYTED_VALUE_PREFIX):])
return password
import os
import time
from com.android.monkeyrunner import MonkeyRunner, MonkeyDevice
from java.io import ByteArrayOutputStream
from java.util.logging import Logger, StreamHandler, SimpleFormatter
errors = ByteArrayOutputStream(100)
logger = Logger.getLogger('com.android.chimpchat.adb.AdbChimpDevice')
logger.addHandler(StreamHandler(errors, SimpleFormatter()))
current_activity = None
def click(device, x, y):
if device is not None:
device.touch(x, y, MonkeyDevice.DOWN_AND_UP)
def drag(device, startx, starty, endx, endy):
if device is not None:
device.drag((startx, starty), (endx, endy), 0.001, 10)
def get_usb_device():
devices = os.popen('adb devices').read().strip().split('\n')[1:]
for name in devices:
device_name = name.split('\t')[0]
if "2967" in device_name:
return True
def get_device():
from java.io import FileInputStream
from java.lang import IllegalStateException
from java.util.logging import Logger, Level
import new
from sets import Set
import PbWlstEntities
from com.muse.fmw.platform import PbProperties
from entities.PbEntity import PbEntity
import pb.PbTypes as PbTypes
# The entity factories (currently only one exists)
LOGGER = Logger.getLogger("entities.EntityUtils")
global ENTITY_FACTORIES
ENTITY_FACTORIES = dict()
def getEntityFactoryWithSource(source):
try:
result = ENTITY_FACTORIES[source]
except KeyError:
result = EntityFactory(source)
ENTITY_FACTORIES[source] = result
return result
def getEntityFactory():
if len(ENTITY_FACTORIES) > 0:
return ENTITY_FACTORIES.items()[len(ENTITY_FACTORIES) - 1][1]
raise IllegalStateException("No entity factory has been created!")
def info(self, message): Logger.getLogger(self.qn).info(message)
from edu.cmu.sphinx.linguist.flat import FlatLinguist
from edu.cmu.sphinx.recognizer import Recognizer
from edu.cmu.sphinx.util import LogMath
from java.util.logging import Logger
from java.util.logging import Level
from java.net import URL
from java.util import ArrayList
# if (args.length < 1) {
# throw new Error("USAGE: GroovyTranscriber <sphinx4 root> [<WAV file>]")
# }
root = "../../../../../../../.."
# init common
Logger.getLogger("").setLevel(Level.WARNING)
logMath = LogMath(1.0001, true)
absoluteBeamWidth = -1
relativeBeamWidth = 1E-80
wordInsertionProbability = 1E-36
languageWeight = 8.0
# init audio data
audioSource = AudioFileDataSource(3200, None)
audioURL = URL("file:" + root + "/src/apps/edu/cmu/sphinx/demo/transcriber/10001-90210-01803.wav")
# (args.length > 1) ?
# File(args[0]).toURI().toURL() :
audioSource.setAudioFile(audioURL, None)
# init front end
from java.util.logging import Logger
logger = Logger.getLogger("WarBase")
st = {}
st['n'] =0
def actionWarBase():
broadcastMessageToAll("", "")
actionWarBase.n+=getNbElementsInBag()
#setDebugString(`st['n']`+`actionWarBase.n`)
for m in getMessages():
if m.getMessage() == "whereAreYouBase":
reply(m,"Here","")
nbEnv = getNbElementsInBag()
if nbEnv > 0:
return createRocketLauncher()
st['n'] += 1
requestRole('gr', 'role')
setDebugString(str(getNumberOfAgentsInRole('gr','role')))
return idle()
actionWarBase.n = 0
def __init__(self): self._log = Logger.getLogger(VLAB.LOGGER_NAME) me=self.__class__.__name__ +'::'+VLAB.me() self._log.info(me + ": constructor completed...") self._log.info(me + ": returning...")
action="store_true", dest="explodeBrep",
help="writes face.<i>.brep file before meshing each patch")
parser.set_defaults(crit="MinAngleFace", scaleFactor=1.0, ifacemin=0, ifacemax=0)
(options, args) = parser.parse_args(args=sys.argv[1:])
if len(args) != 4:
parser.print_usage()
sys.exit(1)
brepfile = args[0]
outputDir = args[1]
leng = float(args[2])
defl = float(args[3])
logger=Logger.getLogger("mesh")
(brepdir, brepfile) = os.path.split(brepfile)
if brepdir is None:
brepdir = "."
phases = [False, False, False, False]
for s in options.phases.split(","):
p = int(s)
if p < 1 or p > 3:
parser.print_usage()
sys.exit(1)
phases[p] = True
#System.setProperty("org.jcae.mesh.amibe.ds.Mesh.epsilon", str(options.epsilon))
#System.setProperty("org.jcae.mesh.amibe.ds.Mesh.cumulativeEpsilon", str(options.cumulativeEpsilon))
'/htmlunit-2.13/lib/commons-codec-1.8.jar',
'/htmlunit-2.13/lib/commons-collections-3.2.1.jar'
]
def loadjars(): #appends jars to jython path
for jar in jars:
#print(jarpath+jar)
container = jarpath+jar
sys.path.append(container)
loadjars()
import java.util.logging.Logger as Logger
import java.util.logging.Level as Level
Logger.getLogger("com.gargoylesoftware").setLevel(Level.OFF);
import com.gargoylesoftware.htmlunit.WebClient as WebClient
webclient = WebClient()
def get_page(page, url):
if page is None:
return webclient.getPage(url)
else:
return page.getPage(url)
def get_first_by_xpath(page, xpath_fmt, *kargs):
xpath = xpath_fmt % kargs
inputs = page.getByXPath(xpath)
#if not inputs:
scaleFactor=1.0,
ifacemin=0,
ifacemax=0)
(options, args) = parser.parse_args(args=sys.argv[1:])
if len(args) != 4:
parser.print_usage()
sys.exit(1)
brepfile = args[0]
outputDir = args[1]
leng = float(args[2])
defl = float(args[3])
logger = Logger.getLogger("mesh")
(brepdir, brepfile) = os.path.split(brepfile)
if brepdir is None:
brepdir = "."
phases = [False, False, False, False]
for s in options.phases.split(","):
p = int(s)
if p < 1 or p > 3:
parser.print_usage()
sys.exit(1)
phases[p] = True
#System.setProperty("org.jcae.mesh.amibe.ds.Mesh.epsilon", str(options.epsilon))
#System.setProperty("org.jcae.mesh.amibe.ds.Mesh.cumulativeEpsilon", str(options.cumulativeEpsilon))
def log_results(self, logger):
"""
:return:
"""
_method_name = 'log_results'
if logger is not None:
# Get counts for all the ValidationResult objects
# in this ValidationResults object
results_summary = self.__get_summary()
jlogger = JLogger.getLogger(logger.get_name(), logger.resource_bundle_name)
jlogger.setLevel(JLevel.INFO)
# Determine what the severity level is going to be for the
# summary log message. Needs to be set in accordance with
# what the severest validation message was.
if results_summary['infos_count'] > 0:
jlogger.setLevel(JLevel.INFO)
if results_summary['warnings_count'] > 0:
jlogger.setLevel(JLevel.WARNING)
if results_summary['errors_count'] > 0:
jlogger.setLevel(JLevel.SEVERE)
total_messages_count = \
int(results_summary['errors_count']) + int(results_summary['warnings_count']) + \
int(results_summary['infos_count'])
logger.log(jlogger.getLevel(),
'WLSDPLY-05204',
results_summary['errors_count'],
results_summary['warnings_count'],
results_summary['infos_count'],
class_name=self._class_name, method_name=_method_name)
if total_messages_count > 0:
logger.log(jlogger.getLevel(), 'WLSDPLY-05207', total_messages_count,
class_name=self._class_name, method_name=_method_name)
for validation_result in self._validation_result_dict.values():
if validation_result.get_infos_count() > 0:
jlogger.setLevel(JLevel.INFO)
self.__log_results_category_details(validation_result.get_infos_messages(),
_method_name, jlogger)
for validation_result in self._validation_result_dict.values():
if validation_result.get_warnings_count() > 0:
jlogger.setLevel(JLevel.WARNING)
self.__log_results_category_details(validation_result.get_warnings_messages(),
_method_name, jlogger)
for validation_result in self._validation_result_dict.values():
if validation_result.get_errors_count() > 0:
jlogger.setLevel(JLevel.SEVERE)
self.__log_results_category_details(validation_result.get_errors_messages(),
_method_name, jlogger)
jlogger.setLevel(JLevel.INFO)
return
from java.util.logging import Logger
logger = Logger.getLogger("WarBase")
st = {}
st['n'] = 0
def actionWarBase():
broadcastMessageToAll("", "")
actionWarBase.n += getNbElementsInBag()
#setDebugString(`st['n']`+`actionWarBase.n`)
for m in getMessages():
if m.getMessage() == "whereAreYouBase":
reply(m, "Here", "")
nbEnv = getNbElementsInBag()
if nbEnv > 0:
return createRocketLauncher()
st['n'] += 1
requestRole('gr', 'role')
setDebugString(str(getNumberOfAgentsInRole('gr', 'role')))
return idle()
actionWarBase.n = 0
import jarray
from java.lang import Exception
from java.util.logging import Logger
from javax.management import ObjectName
from pb.PbWlstLib import connectToAdminServer
from wlst.WlstWrapper import edit, startEdit, cd, ls, pushd, get, popd, save, \
activate, cancelEdit
LOGGER = Logger.getLogger("entities.MigrationUtils")
def rePointAppTargets(userName, password, url, properties):
if connectToAdminServer(userName, password, url):
try:
edit()
startEdit()
cmo = cd('AppDeployments')
i = 1
source = properties.get("migrate.target." + str(i) + ".source")
while source:
destination = properties.get("migrate.target." + str(i) +
".destination")
destinationType = properties.get("migrate.target." + str(i) +
".type")
deployments = ls(returnMap='true')
for deployment in deployments:
print deployment
pushd(deployment + "/Targets")
def dependsOn(who,what):
if (not (File(what)).exists()):
(Logger.getLogger(VLAB.LOGGER_NAME)).info(JString.format ("Error: \"%s\" expected \"%s\" to exist", [who, what]))
def created(who,what):
if (not (File(what)).exists()):
(Logger.getLogger(VLAB.LOGGER_NAME)).info(JString.format ("Error: \"%s\" failed to generate \"%s\"", [who, what]))
def log(self, m):
l = Logger.getLogger(self.qn)
l.info(m)
