コード例 #1
0
    def __createJMXConnection(self):
        "create JMX connection"

        self.__jmxConnection = None
        self.__jmxConnector = None

        try:
            jmxServiceUrl = JMXServiceURL(self.__jmxUrl)
            env = Hashtable()
            cred = array([self.__jmxUser, self.__jmxPassword], String)
            env.put("jmx.remote.credentials", cred)
            logger.info("Connecting to Oracle Coherence MBean Server:" +
                        ` jmxServiceUrl `)
            self.__jmxConnector = JMXConnectorFactory.connect(
                jmxServiceUrl, env)
            self.__jmxConnection = self.__jmxConnector.getMBeanServerConnection(
            )
            logger.info(
                "Successfully connected to Oracle Coherence MBean Server:" +
                ` jmxServiceUrl `)
        except:
            type, value, traceback = sys.exc_info()
            logger.finer("JMX Connection error:" + ` value `)
            self.__jmxConnection = None
            try:
                if self.__jmxConnector:
                    self.__jmxConnector.close()
                    self.__jmxConnector = None
            except:
                type, value, traceback = sys.exc_info()
                logger.finer("JMX Connector close error:" + ` value `)
コード例 #2
0
ファイル: surface.py プロジェクト: jggatc/pyj2d
 def copy(self):
     """
     Return Surface that is a copy of this surface.
     """
     if not self._super_surface:
         img_properties = Hashtable()
         keys = self.getPropertyNames()
         if keys != None:
             for key in keys:
                 img_properties.put(key, self.getProperty(key))
         surface = Surface(
                           self.getColorModel(),
                           self.getData(),
                           self.isAlphaPremultiplied(),
                           img_properties
                          )
         surface._colorkey = self._colorkey
     else:
         surface = Surface((self.width, self.height),
                           BufferedImage.TYPE_INT_ARGB)
         g2d = surface.createGraphics()
         g2d.drawImage(self, 0, 0, None)
         g2d.dispose()
         surface._colorkey = self._colorkey
     return surface
コード例 #3
0
def register_service(service, interface_names, properties=None):
    """
    This function registers the specified service object with the specified
    properties under the specified class names into the Framework.

    Args:
        service (java.lang.Object): the service to register
        interface_names (list): a list of class names
        properties (dict): a dict of properties for the service

    Returns:
        ServiceRegistration: a ServiceRegistration object used to update or
        unregister the service
    """
    if properties:
        from java.util import Hashtable
        properties_hashmap = Hashtable()
        for key, value in properties.iteritems():
            properties_hashmap.put(key, value)
        properties = properties_hashmap
    registered_service = BUNDLE_CONTEXT.registerService(
        interface_names, service, properties)
    for name in interface_names:
        REGISTERED_SERVICES[name] = (service, registered_service)
    #LOG.debug("Registered service: {}".format(service))
    #LOG.debug("REGISTERED_SERVICES: {}".format(REGISTERED_SERVICES))
    return registered_service
コード例 #4
0
ファイル: binding.py プロジェクト: ralle12345/openhab-jython
def hashtable(*key_values):
    """
    :param key_values: 2-tuples of (key, value)
    :return: initialized Hashtable
    """
    ht = Hashtable()
    for k, v in key_values:
        ht.put(k, v)
    return ht
コード例 #5
0
    def test_return_proxy(self):
        "Jython proxies properly return back from Java code"
        class FooVector(Vector):
            bar = 99

        ht = Hashtable()
        fv = FooVector()
        ht.put("a", fv)
        self.assertTrue(fv is ht.get("a"))
コード例 #6
0
    def test_return_proxy(self):
        "Jython proxies properly return back from Java code"
        class FooVector(Vector):
            bar = 99

        ht = Hashtable()
        fv = FooVector()
        ht.put("a", fv)
        self.failUnless(fv is ht.get("a"))
コード例 #7
0
ファイル: binding.py プロジェクト: ralle12345/openhab-jython
def hashtable(*key_values):
    """
    :param key_values: 2-tuples of (key, value)
    :return: initialized Hashtable
    """
    ht = Hashtable()
    for k, v in key_values:
        ht.put(k, v)
    return ht
コード例 #8
0
  def fetch_ldap_group(self, file):
    """
    fetch group mapping from group ldap server
    :param file: output file name
    """
    settings = Hashtable()
    settings.put(Context.INITIAL_CONTEXT_FACTORY, self.args[Constant.LDAP_GROUP_CONTEXT_FACTORY_KEY])
    settings.put(Context.PROVIDER_URL, self.args[Constant.LDAP_GROUP_CONTEXT_PROVIDER_URL_KEY])
    settings.put(Context.SECURITY_PRINCIPAL, self.args[Constant.LDAP_GROUP_CONTEXT_SECURITY_PRINCIPAL_KEY])
    settings.put(Context.SECURITY_CREDENTIALS, self.args[Constant.LDAP_GROUP_CONTEXT_SECURITY_CREDENTIALS_KEY])

    ctx = InitialDirContext(settings)
    search_target = "(objectClass=posixGroup)"
    return_attributes_standard = ['group_id', 'member_ids']
    return_attributes_actual = json.loads(self.args[Constant.LDAP_GROUP_SEARCH_RETURN_ATTRS_KEY])
    return_attributes_map = dict(zip(return_attributes_standard, return_attributes_actual))
    ctls = SearchControls()
    ctls.setReturningAttributes(return_attributes_actual)
    ctls.setSearchScope(SearchControls.SUBTREE_SCOPE)

    ldap_records = []
    org_units = json.loads(self.args[Constant.LDAP_GROUP_SEARCH_DOMAINS_KEY])
    for search_unit in org_units:
      results = ctx.search(search_unit, search_target, ctls)
      for r in results:
        person_attributes = r.getAttributes()
        group = person_attributes.get(return_attributes_map['group_id']).get(0)
        group = re.sub(r"\r|\n", '', group).strip().encode('utf8')
        # skip special group that contains all group users
        if group == 'users':
          continue
        members = person_attributes.get(return_attributes_map['member_ids'])
        if members:
          self.group_map[group] = members
          sort_id = 0
          for member in members.getAll():
            member = re.sub(r"\r|\n", '', member).strip().encode('utf8')
            ldap_group_tuple = [self.group_app_id]
            ldap_group_tuple.append(group)
            ldap_group_tuple.append(sort_id)
            if member in self.ldap_user:
              ldap_group_tuple.append(self.app_id)
            else:
              ldap_group_tuple.append(self.group_app_id)
            ldap_group_tuple.append(member)
            ldap_group_tuple.append(self.wh_exec_id)
            ldap_records.append(ldap_group_tuple)
            sort_id += 1
        else:
          pass
    self.logger.info("%d records found in group accounts" % (len(self.group_map)))

    csv_writer = csv.writer(open(file, "w"), delimiter='\x1a', quoting=csv.QUOTE_MINIMAL, lineterminator="\n")
    csv_writer.writerows(ldap_records)
コード例 #9
0
def lookup(ejbName):
    properties = Hashtable();
    properties.put(lookup_properties.FACTORY_INITIAL_KEY, lookup_properties.FACTORY_INITIAL_VALUE);
    properties.put(lookup_properties.FACTORY_URLPKGS_KEY, lookup_properties.FACTORY_URLPKGS_VALUE);
    properties.put(lookup_properties.PROVIDER_URL_KEY, lookup_properties.PROVIDER_URL_VALUE);
    
    context = InitialContext(properties);
    mylookup = None
    try:
        mylookup = context.lookup(ejbName)
    except CommunicationException, err:
        raise Exception("Error with EJB connection[" + settings.SERVIDOR + ":1099]\n" + str(err))
コード例 #10
0
 def lookup(self, ejbName):
     properties = Hashtable();
     properties.put(FACTORY_INITIAL_KEY, FACTORY_INITIAL_VALUE);
     properties.put(FACTORY_URLPKGS_KEY, FACTORY_URLPKGS_VALUE);
     properties.put(PROVIDER_URL_KEY, PROVIDER_URL_VALUE);
     
     mylookup = None
     try:
         context = InitialContext(properties);
         mylookup = context.lookup(ejbName)
     except NoInitialContextException, err:
         raise Exception("Error with EJB connection[localhost:1099]\n" + str(err))
コード例 #11
0
def ejecutaOSB(userAdmin, passAdmin, portAdmin, hostnameAdmin, ambiente):
 now = datetime.datetime.now()
 sessionName = "SesionScriptOSB_"+str(now.day)+"_"+str(now.month)+"_"+str(now.year)+"_"+ambiente
 print "t3", hostnameAdmin, portAdmin, "/jndi/" + DomainRuntimeServiceMBean.MBEANSERVER_JNDI_NAME
 serviceURL = JMXServiceURL("t3", hostnameAdmin, int(portAdmin), "/jndi/" + DomainRuntimeServiceMBean.MBEANSERVER_JNDI_NAME)
 h = Hashtable()
 h.put(Context.SECURITY_PRINCIPAL, userAdmin)
 h.put(Context.SECURITY_CREDENTIALS, passAdmin)
 h.put(JMXConnectorFactory.PROTOCOL_PROVIDER_PACKAGES, "weblogic.management.remote")
 conn = JMXConnectorFactory.connect(serviceURL, h)

 arregloAllProject = []
 arregloAllProxy = []
 arregloAllBS = []
 arregloAllServicesURI = []
 arregloAllDependentS = []
 
 mbconn = conn.getMBeanServerConnection()
 sm = JMX.newMBeanProxy(mbconn, ObjectName.getInstance(SessionManagementMBean.OBJECT_NAME), SessionManagementMBean)
 sm.createSession(sessionName)
 configMBean = JMX.newMBeanProxy(mbconn, ObjectName.getInstance("com.bea:Name=" + ALSBConfigurationMBean.NAME + "." + sessionName + ",Type=" + ALSBConfigurationMBean.TYPE), ALSBConfigurationMBean)
 print "##############################"
 print "###Se genera conexion a OSB###"
 print "##############################"
 arregloAllProject=displayAllProjectsAndServices(ambiente, configMBean)
 arregloAllProxy=getAllProxyServices(ambiente, configMBean)
 arregloAllBS=getAllBusinessServices(ambiente, configMBean)                               
 arregloAllServicesURI=getAllServiceURIs(ambiente, configMBean)
 arregloAllDependentS=getDependentServices(ambiente, configMBean)
 sm.discardSession(sessionName)
 conn.close()
	
 return arregloAllProject, arregloAllProxy, arregloAllBS, arregloAllServicesURI, arregloAllDependentS
コード例 #12
0
ファイル: LdapExtract.py プロジェクト: alyiwang/WhereHows
  def fetch_ldap_group(self, file):
    """
    fetch group mapping from group ldap server
    :param file: output file name
    """
    self.logger.info("Fetching ldap groups")
    settings = Hashtable()
    settings.put(Context.INITIAL_CONTEXT_FACTORY, self.args[Constant.LDAP_GROUP_CONTEXT_FACTORY_KEY])
    settings.put(Context.PROVIDER_URL, self.args[Constant.LDAP_GROUP_CONTEXT_PROVIDER_URL_KEY])
    settings.put(Context.SECURITY_PRINCIPAL, self.args[Constant.LDAP_GROUP_CONTEXT_SECURITY_PRINCIPAL_KEY])
    settings.put(Context.SECURITY_CREDENTIALS, self.args[Constant.LDAP_GROUP_CONTEXT_SECURITY_CREDENTIALS_KEY])

    ctx = InitialDirContext(settings)
    search_target = "(objectClass=posixGroup)"
    return_attributes_standard = ['group_id', 'member_ids']
    return_attributes_actual = json.loads(self.args[Constant.LDAP_GROUP_SEARCH_RETURN_ATTRS_KEY])
    return_attributes_map = dict(zip(return_attributes_standard, return_attributes_actual))
    ctls = SearchControls()
    ctls.setReturningAttributes(return_attributes_actual)
    ctls.setSearchScope(SearchControls.SUBTREE_SCOPE)

    ldap_records = []
    org_units = json.loads(self.args[Constant.LDAP_GROUP_SEARCH_DOMAINS_KEY])
    for search_unit in org_units:
      results = ctx.search(search_unit, search_target, ctls)
      for r in results:
        person_attributes = r.getAttributes()
        group = person_attributes.get(return_attributes_map['group_id']).get(0)
        group = re.sub(r"\r|\n", '', group).strip().encode('utf8')
        # skip special group that contains all group users
        if group == 'users':
          continue
        members = person_attributes.get(return_attributes_map['member_ids'])
        if members:
          self.group_map[group] = members
          sort_id = 0
          for member in members.getAll():
            member = re.sub(r"\r|\n", '', member).strip().encode('utf8')
            ldap_group_tuple = [self.group_app_id]
            ldap_group_tuple.append(group)
            ldap_group_tuple.append(sort_id)
            if member in self.ldap_user:
              ldap_group_tuple.append(self.app_id)
            else:
              ldap_group_tuple.append(self.group_app_id)
            ldap_group_tuple.append(member)
            ldap_group_tuple.append(self.wh_exec_id)
            ldap_records.append(ldap_group_tuple)
            sort_id += 1
        else:
          pass
    self.logger.info("%d records found in group accounts" % (len(self.group_map)))

    csv_writer = csv.writer(open(file, "w"), delimiter='\x1a', quoting=csv.QUOTE_MINIMAL, lineterminator="\n")
    csv_writer.writerows(ldap_records)
コード例 #13
0
    def __init__(self, debugger):
        self.lastValue = None
        self.debugger = debugger
        MAX_SPEED = debugger.MAX_SPEED
        self.slider = swing.JSlider(swing.JSlider.HORIZONTAL, 0, MAX_SPEED,
                                    self.debugger.speed,
                                    stateChanged=self.stateChanged)
        self.last_speed = self.debugger.speed
        labels = Hashtable()
        labels.put(0, swing.JLabel('slow'))
        labels.put(MAX_SPEED, swing.JLabel('fast'))
        self.slider.labelTable = labels
        self.slider.paintLabels = 1

        self.addButton = swing.JButton(swing.ImageIcon('images/plus.jpg'),
                                       actionPerformed=self.actionPerformed,
                                       toolTipText='add Variable',
                                       preferredSize=BUTTON_SIZE)
        self.deleteButton = swing.JButton(swing.ImageIcon('images/minus.jpg'),
                                       actionPerformed=self.actionPerformed,
                                       toolTipText='remove Variable',
                                       preferredSize=BUTTON_SIZE)
        self.stepButton = swing.JButton(swing.ImageIcon('images/boot.jpg'),
                                        actionPerformed=self.actionPerformed,
                                        toolTipText='step',
                                        preferredSize=BUTTON_SIZE)
	self.pauseIcon = swing.ImageIcon('images/pause.jpg')
	self.runIcon = swing.ImageIcon('images/run.jpg')
        self.runButton = swing.JButton(self.runIcon,
                                        actionPerformed=self.actionPerformed,
                                        toolTipText='run',
                                       preferredSize=BUTTON_SIZE)
        self.fullspeedButton = swing.JButton(swing.ImageIcon('images/fullspeed.jpg'),
                                        actionPerformed=self.actionPerformed,
                                        toolTipText='full speed',
                                       preferredSize=BUTTON_SIZE)
        self.stopButton = swing.JButton(swing.ImageIcon('images/stop.jpg'),
                                        actionPerformed=self.actionPerformed,
                                        toolTipText='stop',
                                        preferredSize=BUTTON_SIZE)
        self.setLayout(swing.BoxLayout(self, swing.BoxLayout.X_AXIS))
        self.add(self.slider)
        self.add(self.addButton)
        self.add(self.deleteButton)
        #self.add(self.stepButton) # These two lines commented out by Brian O because of removed Pause functionality -- 23 June 2008
        #self.add(self.runButton)
        self.add(self.fullspeedButton)
        self.add(self.stopButton)
	self.initialButtonState()
コード例 #14
0
 def test_hashtable(self):
     x = Hashtable()
     x.put('a', 1)
     x.put('b', 2)
     x.put('c', 3)
     x.put((1,2), "xyz")
     y = dict(x)
     self.assertEqual(set(y.items()), set([('a', 1), ('b', 2), ('c', 3), ((1,2), "xyz")]))
コード例 #15
0
 def __init__(self, url):
     env = Hashtable()
     env.put(Context.INITIAL_CONTEXT_FACTORY,
             "com.sun.jndi.ldap.LdapCtxFactory")
     env.put(Context.SECURITY_AUTHENTICATION, "none")
     env.put(Context.PROVIDER_URL, url)
     ctx = InitialDirContext(env)
     self.ctx = ctx
コード例 #16
0
def getdata():
	defaultResultText = "Decoding Failed"
	
	qread = QRCodeReader()
	ip = IJ.getProcessor()
	myimg = ip.getBufferedImage()
	source = BufferedImageLuminanceSource(myimg)
	bitmap = BinaryBitmap(HybridBinarizer(source))
	resultText = defaultResultText
	try :
		hints = Hashtable()
		hints.put(DecodeHintType.TRY_HARDER, True)
		result = qread.decode(bitmap, hints)
		resultText = result.getText()
	except NotFoundException, ex:
		print ex
コード例 #17
0
ファイル: surface.py プロジェクト: jggatc/pyj2d
 def __init__(self, *arg):
     """
     Return Surface that is subclassed from java.awt.image.BufferedImage.
     
     Alternative arguments:
     
     * Size (w,h) of surface, optional second argument of flags (SRCALPHA)
     * Bufferedimage to convert to Surface
     
     Module initialization places pyj2d.Surface in module's namespace.
     """
     try:
         width, height = arg[0]
         try:
             if arg[1] & (BufferedImage.TYPE_INT_ARGB | Const.SRCALPHA):
                 BufferedImage.__init__(self, width, height,
                                        BufferedImage.TYPE_INT_ARGB)
             else:
                 BufferedImage.__init__(self, width, height,
                                        BufferedImage.TYPE_INT_RGB)
         except IndexError:
             BufferedImage.__init__(self, width, height,
                                    BufferedImage.TYPE_INT_ARGB)
             graphics2D = self.createGraphics()
             graphics2D.setColor(Color(0,0,0))
             graphics2D.fillRect(0, 0, width, height)
             graphics2D.dispose()
     except TypeError:
         try:
             cm = arg[0].getColorModel()
             raster = arg[0].getRaster()
             isRasterPremultiplied = arg[0].isAlphaPremultiplied()
             properties = Hashtable()
             keys = arg[0].getPropertyNames()
             if keys != None:
                 for key in keys:
                     properties.put(key, arg[0].getProperty(key))
         except AttributeError:
             cm, raster, isRasterPremultiplied, properties = arg
         BufferedImage.__init__(self, cm, raster,
                                isRasterPremultiplied, properties)
     self._display = None    #display surface
     self._super_surface = None
     self._offset = (0,0)
     self._colorkey = None
     self._nonimplemented_methods()
コード例 #18
0
 def __init__(self,url):
     env = Hashtable()
     env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory")
     env.put(Context.SECURITY_AUTHENTICATION, "none")
     env.put(Context.PROVIDER_URL, url)
     ctx = InitialDirContext(env)
     self.ctx = ctx
コード例 #19
0
ファイル: import-mod.py プロジェクト: eldereis/intelijans
def initConnection(hostname, port, username, password):
	serviceURL = JMXServiceURL("t3", hostname, port,"/jndi/" + DomainRuntimeServiceMBean.MBEANSERVER_JNDI_NAME)
	h=Hashtable()
	h.put(Context.SECURITY_PRINCIPAL, username)
	h.put(Context.SECURITY_CREDENTIALS, password)
	h.put(JMXConnectorFactory.PROTOCOL_PROVIDER_PACKAGES, "weblogic.management.remote")
	return JMXConnectorFactory.connect(serviceURL, h)
コード例 #20
0
 def test_hashtable(self):
     x = Hashtable()
     x.put('a', 1)
     x.put('b', 2)
     x.put('c', 3)
     x.put((1,2), "xyz")
     y = dict(x)
     self.assertEqual(set(y.items()), set([('a', 1), ('b', 2), ('c', 3), ((1,2), "xyz")]))
コード例 #21
0
class TcpDbUtils(discoverydbutils.DiscoveryDbUtils):
    CONTEXT = 'tcpdiscovery'

    TCP_EXECUTED_JOBS = Hashtable()

    def __init__(self, Framework):
        discoverydbutils.DiscoveryDbUtils.__init__(self, Framework,
                                                   TcpDbUtils.CONTEXT)
        self.knownPortsConfigFile = Framework.getConfigFile(
            CollectorsParameters.KEY_COLLECTORS_SERVERDATA_PORTNUMBERTOPORTNAME
        )
        self.applicSignConfigFile = Framework.getConfigFile(
            CollectorsParameters.KEY_COLLECTORS_SERVERDATA_APPLICATIONSIGNATURE
        )
        self.hostID = Framework.getDestinationAttribute('hostId')

        globalSettings = GeneralSettingsConfigFile.getInstance()
        #hours
        self.TCP_EXPIRATION_PERIOD = globalSettings.getPropertyIntegerValue(
            'tcpExpirationTime', 24)
        #milliseconds
        self.PORT_EXPIRATION_PERIOD = globalSettings.getPropertyIntegerValue(
            'portExpirationTime', 60) * 1000L

    def addPortToProcess(self,
                         ipaddress,
                         port,
                         process_pid,
                         listen=0,
                         prot=modeling.TCP_PROTOCOL,
                         ProcessName=None):
        pid = -1
        if process_pid != None:
            pid = int(process_pid)
        port2process = PortToProcess(self.hostID, ipaddress, int(port), pid,
                                     prot, listen, ProcessName)
        self.addToBulk(port2process)

    def flushPortToProcesses(self):
        self.executeUpdate(
            PortToProcess.DELETESQL %
            ('Port_Process', self.hostID,
             str(System.currentTimeMillis() - self.PORT_EXPIRATION_PERIOD)))
        self.executeBulk(PortToProcess.PORTTOPROCESSTYPE)
        TcpDbUtils.TCP_EXECUTED_JOBS.clear()

    def addTcpConnection(self, srcAddr, srcPort, dstAddr, dstPort):
        tcpConnection = TcpConnection(self.hostID, srcAddr, dstAddr, srcPort,
                                      dstPort)
        self.addToBulk(tcpConnection)

    def flushTcpConnection(self):
        self.executeUpdate(TcpConnection.DELETESQL %
                           ('Agg_V5', self.hostID, self.TCP_EXPIRATION_PERIOD))
        self.executeBulk(TcpConnection.TCPCONNECTIONTYPE)
        TcpDbUtils.TCP_EXECUTED_JOBS.clear()
コード例 #22
0
ファイル: surface.py プロジェクト: jggatc/pyj2d
 def __init__(self, *arg):
     """
     Return Surface that is subclassed from java.awt.image.BufferedImage.
     
     Alternative arguments:
     
     * Size (w,h) of surface, optional second argument of flags (SRCALPHA)
     * Bufferedimage to convert to Surface
     
     Module initialization places pyj2d.Surface in module's namespace.
     """
     try:
         width, height = arg[0]
         try:
             if arg[1] & (BufferedImage.TYPE_INT_ARGB | Const.SRCALPHA):
                 BufferedImage.__init__(self, width, height, BufferedImage.TYPE_INT_ARGB)
             else:
                 BufferedImage.__init__(self, width, height, BufferedImage.TYPE_INT_RGB)
         except IndexError:
             BufferedImage.__init__(self, width, height, BufferedImage.TYPE_INT_ARGB)
             graphics2D = self.createGraphics()
             graphics2D.setColor(Color(0,0,0))
             graphics2D.fillRect(0, 0, width, height)
             graphics2D.dispose()
     except TypeError:
         try:
             cm = arg[0].getColorModel()
             raster = arg[0].getRaster()
             isRasterPremultiplied = arg[0].isAlphaPremultiplied()
             properties = Hashtable()
             keys = arg[0].getPropertyNames()
             if keys != None:
                 for key in keys:
                     properties.put(key,arg[0].getProperty(key))
         except AttributeError:
             cm, raster, isRasterPremultiplied, properties = arg
         BufferedImage.__init__(self, cm, raster, isRasterPremultiplied, properties)
     self._display = None    #display surface
     self._super_surface = None
     self._offset = (0,0)
     self._colorkey = None
     self._nonimplemented_methods()
コード例 #23
0
 def test_class_coercion(self):
     c = Coercions()
     from java.util import Hashtable, HashMap
     ht = Hashtable()
     hm = HashMap()
     ht['one'] = 'uno'
     hm['zwei'] = 'two'
     for obj, cls in ((ht, "java.util.Hashtable"), (hm, "java.util.HashMap"), ("abc", "java.lang.String"),
             (1, "java.lang.Integer"), (1.2, "java.lang.Double"), (Hashtable, "java.lang.Class")):
         self.assertEquals(c.tellClassNameSerializable(obj), "class " + cls)
     self.assertEquals(c.tellClassNameObject(ht), "class java.util.Hashtable")
コード例 #24
0
ファイル: dns.py プロジェクト: benc-uk/ziz
def main():
	try:
		record = "A"
		if("record_type" in globals()):
			record = str(record_type)
			
		timer = Timer()
		env = Hashtable()		
		env.put("java.naming.factory.initial", "com.sun.jndi.dns.DnsContextFactory")
		env.put("java.naming.provider.url", "dns://" + dns_server)
		ictx = InitialDirContext(env)	
		attrs = ictx.getAttributes(hostname, [record])
		attr = attrs.get(record)
		result.value = timer.stop()
		result.status = result.STATUS_GOOD
		result.msg = "Query result: " + attr.toString()
		ictx.close()
	except NamingException, e:
		ictx.close()
		result.status = result.STATUS_FAILED
		result.msg = str(e.getMessage())
コード例 #25
0
ファイル: myExpect.py プロジェクト: huhe56/nsm-rest-api
 def ssh(host, usr, pwd, timeout):
     jsch = JSch()
     session = jsch.getSession(usr, host, 22)
     session.setPassword(pwd)
     config = Hashtable()
     config.put('StrictHostKeyChecking', 'no')
     session.setConfig(config)
     session.setDaemonThread(True)
     ''' connect timeout '''
     session.connect(timeout*1000)
     
     channel = session.openChannel('shell')
     channel.setPtyType('vt102')
     
     env = Hashtable()
     channel.setEnv(env)
     
     expect4j = Expect4j(channel.getInputStream(), channel.getOutputStream())
     
     ''' expect return timeout '''
     channel.connect(timeout*1000)
     
     return expect4j
コード例 #26
0
ファイル: surface.py プロジェクト: jggatc/pyj2d
 def copy(self):
     """
     Return Surface that is a copy of this surface.
     """
     if not self._super_surface:
         img_properties = Hashtable()
         keys = self.getPropertyNames()
         if keys != None:
             for key in keys:
                 img_properties.put(key,self.getProperty(key))
         surface = Surface(
                           self.getColorModel(),
                           self.getData(),
                           self.isAlphaPremultiplied(),
                           img_properties
                          )
         surface._colorkey = self._colorkey
     else:
         surface = Surface((self.width,self.height), BufferedImage.TYPE_INT_ARGB)
         g2d = surface.createGraphics()
         g2d.drawImage(self, 0, 0, None)
         g2d.dispose()
         surface._colorkey = self._colorkey
     return surface
コード例 #27
0
ファイル: ldap.py プロジェクト: Deelight-fr/Zimbra-1
	def createLdapContext(cls):
		Log.logMsg(5, "Creating ldap context")
		if cls.cf is None:
			raise Exception("Ldap not initialized")

		env=Hashtable()
		env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory")
		env.put(Context.PROVIDER_URL, 'ldapi:///opt/zimbra/openldap/var/run/ldapi/') 
		env.put(Context.SECURITY_AUTHENTICATION, "simple")
		env.put(Context.SECURITY_PRINCIPAL, "cn=config")
		env.put(Context.SECURITY_CREDENTIALS, cls.cf.ldap_root_password)
		cls.mLdapContext = InitialDirContext(env)

		if cls.cf.ldap_is_master:
			#s = SearchControls()
			#s.setSearchScope(SearchControls.OBJECT_SCOPE)
			Log.logMsg(5, "Creating ldap context")
			ats = BasicAttributes("objectClass", None)
			atr = ['1.1']
			results = cls.mLdapContext.search("cn=accesslog", ats, atr)
			if results.hasMore():
				Log.logMsg(5, "Ldap config is master")
				cls.master = True
コード例 #28
0
def get_java_variables(DICT_1, DICT_2, DICT_3, LIST_1, LIST_2, LIST_3,
                       **extra):
    return dict(STRING_0=String(),
                STRING_1=String('a'),
                STRING_2=String('ab'),
                STRING_3=String('abc'),
                HASHTABLE_0=Hashtable(),
                HASHTABLE_1=create_hashtable(DICT_1),
                HASHTABLE_2=create_hashtable(DICT_2),
                HASHTABLE_3=create_hashtable(DICT_3),
                VECTOR_0=Vector(),
                VECTOR_1=Vector(LIST_1),
                VECTOR_2=Vector(LIST_2),
                VECTOR_3=Vector(LIST_3),
                ARRAY_0=jarray.array([], String),
                ARRAY_1=jarray.array([str(i) for i in LIST_1], String),
                ARRAY_2=jarray.array([str(i) for i in LIST_2], String),
                ARRAY_3=jarray.array([str(i) for i in LIST_3], String))
コード例 #29
0
    def __init__(self, debugger):
        self.lastValue = None
        self.debugger = debugger
        MAX_SPEED = debugger.MAX_SPEED
        self.slider = swing.JSlider(swing.JSlider.HORIZONTAL,
                                    0,
                                    MAX_SPEED,
                                    self.debugger.speed,
                                    stateChanged=self.stateChanged)
        self.last_speed = self.debugger.speed
        labels = Hashtable()
        labels.put(0, swing.JLabel('slow'))
        labels.put(MAX_SPEED, swing.JLabel('fast'))
        self.slider.labelTable = labels
        self.slider.paintLabels = 1

        self.addButton = swing.JButton(swing.ImageIcon('images/plus.jpg'),
                                       actionPerformed=self.actionPerformed,
                                       toolTipText='add Variable',
                                       preferredSize=BUTTON_SIZE)
        self.deleteButton = swing.JButton(swing.ImageIcon('images/minus.jpg'),
                                          actionPerformed=self.actionPerformed,
                                          toolTipText='remove Variable',
                                          preferredSize=BUTTON_SIZE)
        self.stepButton = swing.JButton(swing.ImageIcon('images/boot.jpg'),
                                        actionPerformed=self.actionPerformed,
                                        toolTipText='step',
                                        preferredSize=BUTTON_SIZE)
        self.pauseIcon = swing.ImageIcon('images/pause.jpg')
        self.runIcon = swing.ImageIcon('images/run.jpg')
        self.runButton = swing.JButton(self.runIcon,
                                       actionPerformed=self.actionPerformed,
                                       toolTipText='run',
                                       preferredSize=BUTTON_SIZE)
        self.fullspeedButton = swing.JButton(
            swing.ImageIcon('images/fullspeed.jpg'),
            actionPerformed=self.actionPerformed,
            toolTipText='full speed',
            preferredSize=BUTTON_SIZE)
        self.stopButton = swing.JButton(swing.ImageIcon('images/stop.jpg'),
                                        actionPerformed=self.actionPerformed,
                                        toolTipText='stop',
                                        preferredSize=BUTTON_SIZE)
        self.setLayout(swing.BoxLayout(self, swing.BoxLayout.X_AXIS))
        self.add(self.slider)
        self.add(self.addButton)
        self.add(self.deleteButton)
        #self.add(self.stepButton) # These two lines commented out by Brian O because of removed Pause functionality -- 23 June 2008
        #self.add(self.runButton)
        self.add(self.fullspeedButton)
        self.add(self.stopButton)
        self.initialButtonState()
コード例 #30
0
ファイル: cpanel.py プロジェクト: JoeLeclercq/jesWork
    def __init__(self, interpreter, debugger, debugPanel):
        self.interpreter = interpreter
        self.debugger = debugger
        self.debugPanel = debugPanel

        # Build our slider!
        self.slider = JSlider(JSlider.HORIZONTAL,
                              debugger.MIN_SPEED,
                              debugger.MAX_SPEED,
                              debugger.speed,
                              stateChanged=self._sliderSpeedChanged)

        # Label the slider!
        self.sliderLabels = labels = Hashtable()
        labels.put(debugger.MIN_SPEED, JLabel("Slow"))
        labels.put(debugger.MAX_SPEED, JLabel("Fast"))
        self.slider.labelTable = labels
        self.slider.paintLabels = True

        # Build some buttons!
        self.buttonInsets = Insets(0, 0, 0, 0)
        self.watchButton = self.makeDebuggerButton(
            self.debugPanel.watchVariable, 'images/plus.jpg')
        self.unwatchButton = self.makeDebuggerButton(
            self.debugPanel.unwatchVariable, 'images/minus.jpg')
        self.fullspeedButton = self.makeDebuggerButton(
            self.debugPanel.fullSpeed, 'images/fullspeed.jpg')
        self.stopButton = self.makeDebuggerButton(self.interpreter.stopAction,
                                                  'images/stop.jpg')

        # Display them all!
        self.setLayout(BoxLayout(self, BoxLayout.X_AXIS))
        self.add(self.slider)
        self.add(self.watchButton)
        self.add(self.unwatchButton)
        self.add(self.fullspeedButton)
        self.add(self.stopButton)

        # Connect the slider to the debugger!
        self.debugger.onSpeedSet.connect(self._showSpeedSetting)
        self.debugger.onStart.connect(self._lockControls)
        self.debugger.onStop.connect(self._unlockControls)
コード例 #31
0
ファイル: Netlinks_Service.py プロジェクト: deezeesms/dd-git
class NetlinksService:
    EXECUTED_JOBS = Hashtable()

    def __init__(self, Framework):
        self.Framework = Framework
        self.knownPortsConfigFile = self.Framework.getConfigFile(
            CollectorsParameters.KEY_COLLECTORS_SERVERDATA_PORTNUMBERTOPORTNAME
        )
        self.includeOutscopeServers = self.getBooleanParameter(
            'includeOutscopeServers')
        self.includeOutscopeClients = self.getBooleanParameter(
            'includeOutscopeClients')
        self.ip2ports = HashMap()

    def discover(self):
        logger.debug('Starting netlinks discovery')
        jobFinished = 0
        try:
            if tcpdbutils.shouldDiscoverTCP(self.Framework):
                self.discover_private()
            else:
                if logger.isInfoEnabled():
                    logger.info(
                        'No changes in netlinks database since previous job execution'
                    )
            jobFinished = 1
        finally:
            if logger.isInfoEnabled():
                logger.info('Netlinks discovery finished')
            if not jobFinished:
                #in this case we should clear already executed jobs from cache
                #to enable this job run once again
                tcpdbutils.resetShouldDiscoverTCP(self.Framework)

    def discover_private(self):
        raise NotImplementedError, "discover_private"

    def servicesPorts(self, onlyKnownPorts=1):
        services = self.Framework.getParameter('services')
        if logger.isDebugEnabled():
            logger.debug('Requested services:', services)
        if (services == None) or (len(services) == 0) or (services == '*'):
            if onlyKnownPorts:
                portsInfo = self.knownPortsConfigFile.getTcpPorts()
                services = ''
                delimiter = ''
                for info in portsInfo:
                    services = services + delimiter + str(info.getPortNumber())
                    delimiter = ','
                if len(services) == 0:
                    return services
            else:
                return ''

        names = services.split(',')
        ports = ''
        delimiter = ''
        for name in names:
            portNums = self.knownPortsConfigFile.getPortByName(name)
            if (portNums == None) or (len(portNums) == 0):
                try:
                    portNums = [Integer.parseInt(name)]
                except:
                    logger.debug('Failed to resolve service port number:',
                                 name)
                    continue
            for portNum in portNums:
                ports = ports + delimiter + str(portNum)
                delimiter = ','
        if logger.isDebugEnabled():
            logger.debug('Requested services ports:', ports)
        return ports

    def isIpOutOfScope(self, addr):
        return DomainScopeManager.isIpOutOfScope(addr)

    def shouldInclude(self, addr, isServer):
        if self.isIpOutOfScope(addr):
            if isServer and (not self.includeOutscopeServers):
                return 0
            if (not isServer) and (not self.includeOutscopeClients):
                return 0
        return 1

    def getBooleanParameter(self, paramName):
        paramVaue = self.getParameterValue(paramName)
        if paramVaue == None:
            return 0
        return Boolean.parseBoolean(paramVaue)

    def getParameterValue(self, paramName):
        return self.Framework.getParameter(paramName)

    def createLinkID(self, ip1, ip2):
        return ip1 + '<=>' + ip2
コード例 #32
0
 def test_copy_java_hashtable(self):
     x = Hashtable()
     xc = x.copy()
     self.assertEqual(type(x), type(xc))
コード例 #33
0
 def test_hashtable_equal(self):
     for d in ({}, {1:2}):
         x = Hashtable(d)
         self.assertEqual(x, d)
         self.assertEqual(d, x)
         self.assertEqual(x, HashMap(d))
コード例 #34
0
 def test_hashtable_remove(self):
     x = Hashtable({})
     with self.assertRaises(KeyError):
         del x[0]
コード例 #35
0
 def test_java_dict_likes_are_list_like(self):
     assert_equal(is_list_like(HashMap()), True)
     assert_equal(is_list_like(Hashtable()), True)
コード例 #36
0
ファイル: jndi.py プロジェクト: Gonzaxd3000/rebeca
# Jython Database Specification API 2.0
#
# $Id: jndi.py,v 1.1 2001/12/14 04:20:03 bzimmer Exp $
#
# Copyright (c) 2001 brian zimmer <*****@*****.**>

"""
	This script is used to bind a JNDI reference for testing purposes only.
"""
from java.util import Hashtable
from org.gjt.mm.mysql import MysqlDataSource
from javax.naming import Context, InitialContext, NameAlreadyBoundException

env = Hashtable()
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.fscontext.RefFSContextFactory")

ds = MysqlDataSource()
ds.setServerName("localhost")
ds.setDatabaseName("ziclix")
ds.setPort(3306)

ctx = InitialContext(env)
try:
	try:
		ctx.bind("/jdbc/mysqldb", ds)
	except NameAlreadyBoundException, e:
		ctx.unbind("/jdbc/mysqldb")
		ctx.bind("/jdbc/mysqldb", ds)
finally:
	ctx.close()
コード例 #37
0
 def __init__(self,url,user,pwd,proto):
     env=Hashtable()
     env.put(Context.INITIAL_CONTEXT_FACTORY,"com.sun.jndi.ldap.LdapCtxFactory")
     env.put(Context.SECURITY_AUTHENTICATION,"simple")
     env.put(Context.PROVIDER_URL,url)
     env.put(Context.SECURITY_PRINCIPAL,user)
     env.put(Context.SECURITY_CREDENTIALS,pwd)
     if proto is not None:
         env.put(Context.SECURITY_PROTOCOL,proto)
     ctx=InitialDirContext(env)
     self.url=url
     self.ctx=ctx
コード例 #38
0
def create_hashtable(dictionary):
    ht = Hashtable()
    for key, value in dictionary.items():
        ht.put(key, value)
    return ht
コード例 #39
0
 def test_copy_java_hashtable(self):
     x = Hashtable()
     xc = x.copy()
     self.assertEqual(type(x), type(xc))
コード例 #40
0
ファイル: util.py プロジェクト: lwyszomi/touchforms
def to_hashtable(dict):
    ht = Hashtable()
    for k in dict:
        ht.put(k, dict[k])
    return ht
コード例 #41
0
ファイル: recv.py プロジェクト: esnet/netshell
from com.rabbitmq.client import QueueingConsumer

#
# Created by davidhua on 7/3/14.
#

broker = BrokerInfo()
broker.setHost("localhost")
broker.setUser("david2")
broker.setPassword("123")
broker.setPort(5672)  # Port 5671 for ssl
broker.setSSL(False)  # True for no ssl

HOME_FILE = "/var/netshell/users/admin"
permissions = Hashtable()

# Get name of queue to receive messages from from file.
uuidQueue = UUIDManager(HOME_FILE)
queueName = uuidQueue.checkUUID()
# Create connection and queue
factory = SSLConnection(broker).createConnection()
connection = factory.newConnection()
channel = connection.createChannel()

channel.queueDeclare(queueName, False, False, True, None)

try:
    consumer = QueueingConsumer(channel)
    # Declare as exclusive consumer of queue
    channel.basicConsume(queueName, True, "consumer", False, True, None,
コード例 #42
0
list2 = ['a', 'b']
list3 = ['a', 'b', 'c']
dict0 = {}
dict1 = {'a': 1}
dict2 = {'a': 1, 'b': 2}
dict3 = {'a': 1, 'b': 2, 'c': 3}
custom0 = _Custom(0)
custom1 = _Custom(1)
custom2 = _Custom(2)
custom3 = _Custom(3)
length_method = _LengthMethod()
size_method = _SizeMethod()
length_attribute = _LengthAttribute()
if os.name == 'java':
    string0 = String()
    string1 = String('a')
    string2 = String('ab')
    string3 = String('abc')
    hashtable0 = Hashtable()
    hashtable1 = _create_hashtable(dict1)
    hashtable2 = _create_hashtable(dict2)
    hashtable3 = _create_hashtable(dict3)
    vector0 = Vector()
    vector1 = Vector(list1)
    vector2 = Vector(list2)
    vector3 = Vector(list3)
    array0 = jarray.array(list0, String)
    array1 = jarray.array(list1, String)
    array2 = jarray.array(list2, String)
    array3 = jarray.array(list3, String)
コード例 #43
0
ファイル: recv.py プロジェクト: esnet/netshell
from com.rabbitmq.client import QueueingConsumer

#
# Created by davidhua on 7/3/14.
#

broker = BrokerInfo()
broker.setHost("localhost")
broker.setUser("david2")
broker.setPassword("123")
broker.setPort(5672) # Port 5671 for ssl
broker.setSSL(False) # True for no ssl

HOME_FILE = "/var/netshell/users/admin"
permissions = Hashtable()

# Get name of queue to receive messages from from file.
uuidQueue = UUIDManager(HOME_FILE)
queueName = uuidQueue.checkUUID()
# Create connection and queue
factory = SSLConnection(broker).createConnection()
connection = factory.newConnection()
channel = connection.createChannel()

channel.queueDeclare(queueName, False, False, True, None)

try:
    consumer = QueueingConsumer(channel)
    # Declare as exclusive consumer of queue
    channel.basicConsume(queueName, True, "consumer", False, True, None, consumer)
コード例 #44
0
ファイル: jndi.py プロジェクト: walkabout21/OpenModelSphere
# Jython Database Specification API 2.0
#
# $Id: jndi.py 1962 2001-12-14 04:20:03Z bzimmer $
#
# Copyright (c) 2001 brian zimmer <*****@*****.**>
"""
	This script is used to bind a JNDI reference for testing purposes only.
"""
from java.util import Hashtable
from org.gjt.mm.mysql import MysqlDataSource
from javax.naming import Context, InitialContext, NameAlreadyBoundException

env = Hashtable()
env.put(Context.INITIAL_CONTEXT_FACTORY,
        "com.sun.jndi.fscontext.RefFSContextFactory")

ds = MysqlDataSource()
ds.setServerName("localhost")
ds.setDatabaseName("ziclix")
ds.setPort(3306)

ctx = InitialContext(env)
try:
    try:
        ctx.bind("/jdbc/mysqldb", ds)
    except NameAlreadyBoundException, e:
        ctx.unbind("/jdbc/mysqldb")
        ctx.bind("/jdbc/mysqldb", ds)
finally:
    ctx.close()
コード例 #45
0
ファイル: LdapExtract.py プロジェクト: linwenxue/WhereHows
  def fetch_ldap_user(self, file):
    """
    fetch ldap user from ldap server
    :param file: output file name
    """

    # Setup LDAP Context Options
    settings = Hashtable()
    settings.put(Context.INITIAL_CONTEXT_FACTORY, self.args[Constant.LDAP_CONTEXT_FACTORY_KEY])
    settings.put(Context.PROVIDER_URL, self.args[Constant.LDAP_CONTEXT_PROVIDER_URL_KEY])
    settings.put(Context.SECURITY_PRINCIPAL, self.args[Constant.LDAP_CONTEXT_SECURITY_PRINCIPAL_KEY])
    settings.put(Context.SECURITY_CREDENTIALS, self.args[Constant.LDAP_CONTEXT_SECURITY_CREDENTIALS_KEY])

    # page the result, each page have fix number of records
    pageSize = 5000
    pageControl = PagedResultsControl(pageSize, Control.NONCRITICAL)
    c_array = array([pageControl], Control)

    # Connect to LDAP Server
    ctx = InitialLdapContext(settings, None)
    ctx.setRequestControls(c_array)

    # load the java Hashtable out of the ldap server
    # Query starting point and query target
    search_target = '(objectClass=person)'
    return_attributes_standard = ['user_id', 'distinct_name', 'name', 'display_name', 'title', 'employee_number',
                                  'manager', 'mail', 'department_number', 'department', 'start_date', 'mobile']
    return_attributes_actual = json.loads(self.args[Constant.LDAP_SEARCH_RETURN_ATTRS_KEY])
    return_attributes_map = dict(zip(return_attributes_standard, return_attributes_actual))

    ctls = SearchControls()
    ctls.setReturningAttributes(return_attributes_actual)
    ctls.setSearchScope(SearchControls.SUBTREE_SCOPE)
    ldap_records = []

    # domain format should look like : ['OU=domain1','OU=domain2','OU=domain3,OU=subdomain3']
    org_units = json.loads(self.args[Constant.LDAP_SEARCH_DOMAINS_KEY])

    cookie = None
    for search_unit in org_units:
      # pagination
      while True:
        # do the search
        search_result = ctx.search(search_unit, search_target, ctls)
        for person in search_result:
          ldap_user_tuple = [self.app_id]
          if search_unit == self.args[Constant.LDAP_INACTIVE_DOMAIN_KEY]:
            ldap_user_tuple.append('N')
          else:
            ldap_user_tuple.append('Y')
          person_attributes = person.getAttributes()
          user_id = person_attributes.get(return_attributes_map['user_id'])
          user_id = re.sub(r"\r|\n", '', user_id.get(0)).strip().encode('utf8')
          self.ldap_user.add(user_id)

          for attr_name in return_attributes_actual:
            attr = person_attributes.get(attr_name)
            if attr:
              attr = re.sub(r"\r|\n", '', attr.get(0)).strip().encode('utf8')
              # special fix for start_date
              if attr_name == return_attributes_map['start_date'] and len(attr) == 4:
                attr += '0101'
              ldap_user_tuple.append(attr)
            else:
              ldap_user_tuple.append("")

          ldap_user_tuple.append(self.wh_exec_id)
          ldap_records.append(ldap_user_tuple)

        # Examine the paged results control response
        control = ctx.getResponseControls()[0] # will always return a list, but only have one item
        if isinstance(control, PagedResultsResponseControl):
          cookie = control.getCookie()

        # Re-activate paged results
        if cookie is None:
          # reset ctx, break while loop, do next search
          pageControl = PagedResultsControl(pageSize, Control.NONCRITICAL)
          c_array = array([pageControl], Control)
          ctx.setRequestControls(c_array)
          break
        else:
          self.logger.debug("Have more than one page of result when search " + search_unit)
          pageControl = PagedResultsControl(pageSize, cookie, Control.CRITICAL)
          c_array = array([pageControl], Control)
          ctx.setRequestControls(c_array)

    self.logger.info("%d records found in ldap search" % (len(self.ldap_user)))

    csv_writer = csv.writer(open(file, "w"), delimiter='\x1a', quoting=csv.QUOTE_MINIMAL, lineterminator="\n")
    csv_writer.writerows(ldap_records)
コード例 #46
0
ファイル: test153.py プロジェクト: certik/jython
 def isEmpty(self):
      return Hashtable.isEmpty(self)
コード例 #47
0
ファイル: LdapExtract.py プロジェクト: 0xqq/WhereHows
  def fetch_ldap_user(self, file):
    """
    fetch ldap user from ldap server
    :param file: output file name
    """

    # Setup LDAP Context Options
    settings = Hashtable()
    settings.put(Context.INITIAL_CONTEXT_FACTORY, self.args[Constant.LDAP_CONTEXT_FACTORY_KEY])
    settings.put(Context.PROVIDER_URL, self.args[Constant.LDAP_CONTEXT_PROVIDER_URL_KEY])
    settings.put(Context.SECURITY_PRINCIPAL, self.args[Constant.LDAP_CONTEXT_SECURITY_PRINCIPAL_KEY])
    settings.put(Context.SECURITY_CREDENTIALS, self.args[Constant.LDAP_CONTEXT_SECURITY_CREDENTIALS_KEY])

    # Connect to LDAP Server
    ctx = InitialDirContext(settings)

    # load the java Hashtable out of the ldap server
    # Query starting point and query target
    search_target = '(objectClass=person)'
    return_attributes_standard = ['user_id', 'distinct_name', 'name', 'display_name', 'title', 'employee_number',
                                  'manager', 'mail', 'department_number', 'department', 'start_date', 'mobile']
    return_attributes_actual = self.split_property(self.args[Constant.LDAP_SEARCH_RETURN_ATTRS_KEY])
    return_attributes_map = dict(zip(return_attributes_standard, return_attributes_actual))

    ctls = SearchControls()
    ctls.setReturningAttributes(return_attributes_actual)
    ctls.setSearchScope(SearchControls.SUBTREE_SCOPE)
    ldap_records = []

    # domain format should look like : 'OU=domain1','OU=domain2','OU=domain3,OU=subdomain3'
    org_units = self.split_property(self.args[Constant.LDAP_SEARCH_DOMAINS_KEY])

    for search_unit in org_units:
      search_result = ctx.search(search_unit, search_target, ctls)

      # print search_return_attributes
      for person in search_result:
        ldap_user_tuple = [self.app_id]
        if search_unit == self.args[Constant.LDAP_INACTIVE_DOMAIN_KEY]:
          ldap_user_tuple.append('N')
        else:
          ldap_user_tuple.append('Y')
        person_attributes = person.getAttributes()
        user_id = person_attributes.get(return_attributes_map['user_id'])
        user_id = re.sub(r"\r|\n", '', user_id.get(0)).strip().encode('utf8')
        self.ldap_user.add(user_id)

        for attr_name in return_attributes_actual:
          attr = person_attributes.get(attr_name)
          if attr:
            attr = re.sub(r"\r|\n", '', attr.get(0)).strip().encode('utf8')
            # special fix for start_date
            if attr_name == return_attributes_map['start_date'] and len(attr) == 4:
              attr += '0101'
            ldap_user_tuple.append(attr)
          else:
            ldap_user_tuple.append("")

        ldap_user_tuple.append(self.wh_exec_id)
        ldap_records.append(ldap_user_tuple)

    self.logger.info("%d records found in ldap search" % (len(self.ldap_user)))

    csv_writer = csv.writer(open(file, "w"), delimiter='\x1a', quoting=csv.QUOTE_MINIMAL, lineterminator="\n")
    csv_writer.writerows(ldap_records)
    def fetch_ldap_user(self, file):
        """
    fetch ldap user from ldap server
    :param file: output file name
    """
        self.logger.info("Fetching ldap users")
        # Setup LDAP Context Options
        settings = Hashtable()
        settings.put(Context.INITIAL_CONTEXT_FACTORY,
                     self.args[Constant.LDAP_CONTEXT_FACTORY_KEY])
        settings.put(Context.PROVIDER_URL,
                     self.args[Constant.LDAP_CONTEXT_PROVIDER_URL_KEY])
        settings.put(Context.SECURITY_PRINCIPAL,
                     self.args[Constant.LDAP_CONTEXT_SECURITY_PRINCIPAL_KEY])
        settings.put(Context.SECURITY_CREDENTIALS,
                     self.args[Constant.LDAP_CONTEXT_SECURITY_CREDENTIALS_KEY])

        # page the result, each page have fix number of records
        pageSize = 5000
        pageControl = PagedResultsControl(pageSize, Control.NONCRITICAL)
        c_array = array([pageControl], Control)

        # Connect to LDAP Server
        ctx = InitialLdapContext(settings, None)
        ctx.setRequestControls(c_array)

        # load the java Hashtable out of the ldap server
        # Query starting point and query target
        search_target = '(objectClass=person)'
        return_attributes_standard = [
            'user_id', 'distinct_name', 'name', 'display_name', 'title',
            'employee_number', 'manager', 'mail', 'department_number',
            'department', 'start_date', 'mobile'
        ]
        return_attributes_actual = json.loads(
            self.args[Constant.LDAP_SEARCH_RETURN_ATTRS_KEY])
        return_attributes_map = dict(
            zip(return_attributes_standard, return_attributes_actual))

        ctls = SearchControls()
        ctls.setReturningAttributes(return_attributes_actual)
        ctls.setSearchScope(SearchControls.SUBTREE_SCOPE)
        ldap_records = []

        # domain format should look like : ['OU=domain1','OU=domain2','OU=domain3,OU=subdomain3']
        org_units = json.loads(self.args[Constant.LDAP_SEARCH_DOMAINS_KEY])

        cookie = None
        for search_unit in org_units:
            # pagination
            while True:
                # do the search
                search_result = ctx.search(search_unit, search_target, ctls)
                for person in search_result:
                    ldap_user_tuple = [self.app_id]
                    if search_unit == self.args[
                            Constant.LDAP_INACTIVE_DOMAIN_KEY]:
                        ldap_user_tuple.append('N')
                    else:
                        ldap_user_tuple.append('Y')
                    person_attributes = person.getAttributes()
                    user_id = person_attributes.get(
                        return_attributes_map['user_id'])
                    user_id = re.sub(r"\r|\n", '',
                                     user_id.get(0)).strip().encode('utf8')
                    self.ldap_user.add(user_id)

                    for attr_name in return_attributes_actual:
                        attr = person_attributes.get(attr_name)
                        if attr:
                            attr = re.sub(r"\r|\n", '',
                                          attr.get(0)).strip().encode('utf8')
                            # special fix for start_date
                            if attr_name == return_attributes_map[
                                    'start_date'] and len(attr) == 4:
                                attr += '0101'
                            ldap_user_tuple.append(attr)
                        else:
                            ldap_user_tuple.append("")

                    ldap_user_tuple.append(self.wh_exec_id)
                    ldap_records.append(ldap_user_tuple)

                # Examine the paged results control response
                control = ctx.getResponseControls()[
                    0]  # will always return a list, but only have one item
                if isinstance(control, PagedResultsResponseControl):
                    cookie = control.getCookie()

                # Re-activate paged results
                if cookie is None:
                    # reset ctx, break while loop, do next search
                    pageControl = PagedResultsControl(pageSize,
                                                      Control.NONCRITICAL)
                    c_array = array([pageControl], Control)
                    ctx.setRequestControls(c_array)
                    break
                else:
                    self.logger.debug(
                        "Have more than one page of result when search " +
                        search_unit)
                    pageControl = PagedResultsControl(pageSize, cookie,
                                                      Control.CRITICAL)
                    c_array = array([pageControl], Control)
                    ctx.setRequestControls(c_array)

        self.logger.info("%d records found in ldap search" %
                         (len(self.ldap_user)))

        csv_writer = csv.writer(open(file, "w"),
                                delimiter='\x1a',
                                quoting=csv.QUOTE_MINIMAL,
                                lineterminator="\n")
        csv_writer.writerows(ldap_records)
コード例 #49
0
    
    refs = bContext.getServiceReferences(str(AlgorithmFactory), filter)
    return refs

def getAlgorithm(ref):
    if ref:
        return bContext.getService(ref)

def getService(service):
    return bContext.getService(bContext.getServiceReference(str(service)))

from org.cishell.framework.data import BasicData

refs = findAlgorithms()
factory = getAlgorithm(refs[2])
alg = factory.createAlgorithm([BasicData(None)],Hashtable(),ciContext)
dm1 = alg.execute()

dm2 = [BasicDataModel("100"),]
factory = getAlgorithm(refs[0])
alg = factory.createAlgorithm(dm2,Hashtable(),ciContext)
dm3 = alg.execute()

factory = getAlgorithm(refs[1])
alg = factory.createAlgorithm(dm3,Hashtable(),ciContext)
dm4 = alg.execute()


# possible other commands
from org.osgi.service.log import LogService
log = getService(LogService)
コード例 #50
0
def _create_hashtable(dictionary):
    ht = Hashtable()
    for key, value in dictionary.items():
        ht.put(key, value)
    return ht
コード例 #51
0
    def __init__(self):

        # Setup controls - buttons first
        self.playButton.preferredSize = self.refreshButton.preferredSize
        self.playButton.actionCommand = self.PLAY
        self.playButton.actionPerformed = self.whenButtonClicked
        self.pauseButton.preferredSize = self.refreshButton.preferredSize
        self.pauseButton.actionCommand = self.PAUSE
        self.pauseButton.actionPerformed = self.whenButtonClicked
        self.stopButton.preferredSize = self.refreshButton.preferredSize
        self.stopButton.actionCommand = self.STOP
        self.stopButton.actionPerformed = self.whenButtonClicked
        self.refreshButton.actionCommand = self.REFRESH
        self.refreshButton.actionPerformed = self.whenButtonClicked

        # Now combobox and text field
        self.sourceCombo.itemStateChanged = self.whenSourceChanged
        self.updateSourcesList()
        self.rangeSpinner.stateChanged = self.whenRangeChanged

        # Now sliders
        ticksMajor = int(self.posMinMax / 4)
        ticksMinor = int(ticksMajor / 5)
        labels = Hashtable(3)
        labels.put(-self.posMinMax, JLabel("Left"))
        labels.put(0, JLabel("Centre"))
        labels.put(self.posMinMax, JLabel("Right"))
        self.positionXSlider.labelTable = labels
        self.positionXSlider.minimum = -self.posMinMax
        self.positionXSlider.maximum = self.posMinMax
        self.positionXSlider.majorTickSpacing = ticksMajor
        self.positionXSlider.minorTickSpacing = ticksMinor
        self.positionXSlider.paintTicks = True
        self.positionXSlider.paintLabels = True
        self.positionXSlider.snapToTicks = True
        self.positionXSlider.value = 0
        self.positionXSlider.stateChanged = self.whenSliderXChanged
        labels = Hashtable(3)
        labels.put(-self.posMinMax, JLabel("Behind"))
        labels.put(0, JLabel("Centre"))
        labels.put(self.posMinMax, JLabel("In-front"))
        self.positionYSlider.labelTable = labels
        self.positionYSlider.minimum = -self.posMinMax
        self.positionYSlider.maximum = self.posMinMax
        self.positionYSlider.majorTickSpacing = ticksMajor
        self.positionYSlider.minorTickSpacing = ticksMinor
        self.positionYSlider.paintTicks = True
        self.positionYSlider.paintLabels = True
        self.positionYSlider.snapToTicks = True
        self.positionYSlider.value = 0
        self.positionYSlider.orientation = JSlider.VERTICAL
        self.positionYSlider.stateChanged = self.whenSliderYChanged
        labels = Hashtable(3)
        labels.put(-self.posMinMax, JLabel("Below"))
        labels.put(0, JLabel("Centre"))
        labels.put(self.posMinMax, JLabel("Above"))
        self.positionZSlider.labelTable = labels
        self.positionZSlider.minimum = -self.posMinMax
        self.positionZSlider.maximum = self.posMinMax
        self.positionZSlider.majorTickSpacing = ticksMajor
        self.positionZSlider.minorTickSpacing = ticksMinor
        self.positionZSlider.paintTicks = True
        self.positionZSlider.paintLabels = True
        self.positionZSlider.snapToTicks = True
        self.positionZSlider.value = 0
        self.positionZSlider.orientation = JSlider.VERTICAL
        self.positionZSlider.stateChanged = self.whenSliderZChanged

        # Setup frame
        self.title = "Simple JMRI Audio Player"
        self.contentPane.layout = BoxLayout(self.contentPane, BoxLayout.Y_AXIS)

        # Add controls to frame - combo & buttons first
        p = JPanel(FlowLayout(FlowLayout.LEADING))
        p.add(self.sourceCombo)
        p.add(self.refreshButton)
        p.add(self.playButton)
        p.add(self.pauseButton)
        p.add(self.stopButton)
        #p.add(JLabel("Range"))
        #p.add(self.rangeSpinner)
        self.add(p)
        self.add(Box.createVerticalGlue())

        # Now sliders
        p = JPanel(FlowLayout(FlowLayout.LEADING))
        label = JLabel("Y Position")
        label.UI = VerticalLabelUI()  # Default behaviour is anti-clockwise
        p.add(label)
        p.add(self.positionYSlider)
        p2 = JPanel()
        p2.layout = BoxLayout(p2, BoxLayout.Y_AXIS)
        p3 = JPanel()
        p3.add(JLabel("Range"))
        p3.add(self.rangeSpinner)
        p2.add(p3)
        #p2.add(Box.createVerticalGlue())
        p3 = JPanel()
        p3.layout = BoxLayout(p3, BoxLayout.Y_AXIS)
        label = JLabel("X Position")
        label.alignmentX = JLabel.CENTER_ALIGNMENT
        p3.add(label)
        p3.add(self.positionXSlider)
        p2.add(p3)
        p.add(p2)
        label = JLabel("Z Position")
        label.UI = VerticalLabelUI()
        p.add(label)
        p.add(self.positionZSlider)
        self.add(p)

        # Finally pack and show
        self.pack()
        self.show()
コード例 #52
0
 def test_java_maps(self):
     assert_equal(is_dict_like(HashMap()), True)
     assert_equal(is_dict_like(Hashtable()), True)
コード例 #53
0
def DiscoveryMain(Framework):
    vector = ObjectStateHolderVector()
    protocol = Framework.getDestinationAttribute('Protocol')
    client = None
    shell = None
    try:
        try:
            # connect to destination
            client = Framework.createClient()
            # wrap client with Shell
            shell = shellutils.ShellFactory().createShell(client)
        except AuthenticationException, ae:
            errormessages.resolveAndReport(ae.getMessage(), protocol,
                                           Framework)
        except:
            exInfo = logger.prepareJythonStackTrace('')
            errormessages.resolveAndReport(exInfo, protocol, Framework)
        else:

            language = Framework.getDestinationAttribute('language')
            hostCmdbId = Framework.getDestinationAttribute('hostId')

            # configure internationalization support
            if language and language != 'NA':
                langBund = Framework.getEnvironmentInformation().getBundle(
                    'langHost_Resources_By_TTY', language)
            else:
                langBund = Framework.getEnvironmentInformation().getBundle(
                    'langHost_Resources_By_TTY')

            # discovery
            discoverCPUs = Boolean.parseBoolean(
                Framework.getParameter('discoverCPUs'))
            discoverDisks = Boolean.parseBoolean(
                Framework.getParameter('discoverDisks'))
            discoveriSCSIInfo = Boolean.parseBoolean(
                Framework.getParameter('discoveriSCSIInfo'))
            discoverDrivers = Boolean.parseBoolean(
                Framework.getParameter('discoverDrivers'))
            discoverMemory = Boolean.parseBoolean(
                Framework.getParameter('discoverMemory'))
            discoverSoftware = Boolean.parseBoolean(
                Framework.getParameter('discoverInstalledSoftware'))
            discoverUsers = Boolean.parseBoolean(
                Framework.getParameter('discoverUsers'))
            discoverServices = Boolean.parseBoolean(
                Framework.getParameter('discoverServices'))
            discoverShares = Boolean.parseBoolean(
                Framework.getParameter('discoverShares'))
            discoverP2P = Boolean.parseBoolean(
                Framework.getParameter('discoverP2P'))

            try:

                hostOsh = modeling.createOshByCmdbIdString('host', hostCmdbId)

                if discoverShares:
                    try:
                        vector.addAll(_discoverSharedResources(shell, hostOsh))
                    except:
                        errorMessage = 'Failed to discover shared resources'
                        _logWarn(
                            errorcodes.
                            FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                            ['share', protocol], errorMessage)

                if discoverCPUs:
                    try:
                        vector.addAll(
                            TTY_HR_CPU_Lib.disWinOS(hostCmdbId, shell,
                                                    Framework, langBund))
                    except:
                        errorMessage = 'Failed to discover CPUs'
                        _logWarn(
                            errorcodes.
                            FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                            ['cpus', protocol], errorMessage)

                if discoverDisks:
                    try:
                        vector.addAll(TTY_HR_Disk_Lib.disWinOS(hostOsh, shell))
                    except:
                        errorMessage = 'Failed to discover disks'
                        _logWarn(
                            errorcodes.
                            FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                            ['disks', protocol], errorMessage)

                if discoverDrivers and shell.isWinOs():
                    try:
                        vector.addAll(
                            _discoverWindowsDeviceDriver(shell, hostOsh))
                    except:
                        errorMessage = 'Failed to discover windows device driver by powershell'
                        _logWarn(
                            errorcodes.
                            FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                            ['windows device driver', protocol], errorMessage)

                if discoveriSCSIInfo:
                    try:
                        vector.addAll(
                            TTY_HR_Disk_Lib.disWinOSiSCSIInfo(hostOsh, shell))
                    except:
                        errorMessage = 'Failed to discover iSCSI info'
                        _logWarn(
                            errorcodes.
                            FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                            ['iSCSI', protocol], errorMessage)

                if discoverMemory:
                    try:
                        vector.addAll(
                            TTY_HR_Memory_Lib.disWinOS(hostCmdbId, shell,
                                                       Framework, langBund))
                    except:
                        errorMessage = 'Failed to discover memory'
                        _logWarn(
                            errorcodes.
                            FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                            ['memory', protocol], errorMessage)

                processes = []
                try:
                    processesDiscoverer = process_discoverer.DiscovererByShellOnWindows(
                        shell)
                    processes = processesDiscoverer.discoverAllProcesses()
                    if not processes:
                        raise ValueError()
                except:
                    errorMessage = 'Failed to discover processes'
                    _logWarn(
                        errorcodes.
                        FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                        ['processes', protocol], errorMessage)

                if processes:
                    # save processes to DB
                    process_discoverer.saveProcessesToProbeDb(
                        processes, hostCmdbId, Framework)

                    # report processes
                    discoverProcesses = Boolean.parseBoolean(
                        Framework.getParameter('discoverProcesses'))
                    if discoverProcesses:
                        processReporter = process.Reporter()
                        for processObject in processes:
                            processVector = processReporter.reportProcess(
                                hostOsh, processObject)
                            vector.addAll(processVector)

                if discoverUsers:
                    try:
                        vector.addAll(_discoverUsers(hostOsh, shell))
                    except:
                        errorMessage = 'Failed to discover users'
                        _logWarn(
                            errorcodes.
                            FAILED_DISCOVERING_RESOURCE_WITH_CLIENT_TYPE,
                            ['users', protocol], errorMessage)

                cmdLineToInstalledSoftware = {}
                softNameToInstSoftOSH = {}
                if discoverSoftware:
                    try:
                        softwareOSHs = TTY_HR_Software_Lib.disWinOS(
                            hostCmdbId, shell, Framework, langBund,
                            softNameToInstSoftOSH)
                        if softwareOSHs:
                            vector.addAll(softwareOSHs)
                    except:
                        errorMessage = 'Failed to discover installed software'
                        _logWarn(errorcodes.FAILED_DISCOVERING_RESOURCE,
                                 ['installed software', protocol],
                                 errorMessage)

                servicesByCmd = Hashtable()
                if discoverServices:
                    try:
                        srvcOSHs = NTCMD_HR_REG_Service_Lib.doService(
                            shell, hostOsh, servicesByCmd, langBund, Framework)
                        vector.addAll(srvcOSHs)
                    except:
                        errorMessage = 'Failed to discover services'
                        _logWarn(errorcodes.FAILED_DISCOVERING_RESOURCE,
                                 ['services', protocol], errorMessage)

                connectivityEndPoints = []
                try:
                    tcpDiscoverer = Dis_TCP.getDiscovererByShell(
                        client, Framework, shell)
                    if tcpDiscoverer is not None:
                        tcpDiscoverer.discoverTCP()
                        connectivityEndPoints = tcpDiscoverer.getProcessEndPoints(
                        )
                except:
                    errorMessage = 'Failed to run TCP discovery'
                    _logWarn(
                        errorcodes.FAILED_RUNNING_DISCOVERY_WITH_CLIENT_TYPE,
                        ['tcp', protocol], errorMessage)

                appSign = applications.createApplicationSignature(
                    Framework, client, shell)

                if processes:
                    appSign.setProcessesManager(
                        applications.ProcessesManager(processes,
                                                      connectivityEndPoints))

                servicesInfo = applications.ServicesInfo(servicesByCmd)
                appSign.setServicesInfo(servicesInfo)

                softwareInfo = applications.InstalledSoftwareInfo(
                    cmdLineToInstalledSoftware, softNameToInstSoftOSH)
                appSign.setInstalledSoftwareInfo(softwareInfo)

                appSign.getApplicationsTopology(hostCmdbId)

                if discoverP2P:
                    try:
                        p2p = process_to_process.ProcessToProcess(Framework)
                        p2p.getProcessesToProcess()
                    except:
                        errorMessage = 'Failed to run p2p discovery'
                        _logWarn(errorcodes.FAILED_RUNNING_DISCOVERY,
                                 ['p2p', protocol], errorMessage)

            except JException, ex:
                exInfo = ex.getMessage()
                errormessages.resolveAndReport(exInfo, protocol, Framework)
            except:
コード例 #54
0
ファイル: tools.py プロジェクト: gahoekstraibm/WDR
def exportApplicationManifest(appName, customTaskProcessors={}):
    taskProcessors = {}
    taskProcessors.update(defaultTaskProcessors)
    taskProcessors.update(customTaskProcessors)
    prefs = Hashtable()
    appManagement = getJMXMBean1(type='AppManagement')
    manifest = ApplicationObject(appName, '../applications/%s.ear' % appName)
    deployment = getid1('/Deployment:%s/' % appName)
    appDeployment = deployment.deployedObject
    manifest.extras['startingWeight'] = '%d' % appDeployment.startingWeight
    manifest.extras['classLoadingMode'] = '%s' % appDeployment.classloader.mode
    webModuleClassLoadingModes = []
    for module in appDeployment.modules:
        if module._type == 'WebModuleDeployment':
            webModuleClassLoadingModes.append(
                [module.uri, module.classloaderMode])
    if webModuleClassLoadingModes:
        manifest.extras['webModuleClassLoadingMode'] = (
            webModuleClassLoadingModes)
    scaMapping = {}
    try:
        for moduleInfo in [
                l.split(':') for l in AdminTask.listSCAModules().splitlines()
        ]:
            scaMapping[moduleInfo[1]] = moduleInfo[0]
    except AttributeError:
        pass
    scaModuleName = scaMapping.get(appName)
    if scaModuleName:
        try:
            manifest.extras['scaModuleProperties'] = [
                [scaModuleName] + l.split('=')
                for l in AdminTask.showSCAModuleProperties([
                    '-moduleName', scaModuleName, '-applicationName', appName
                ]).splitlines()
            ]
        except:
            pass
        try:
            scaImportWSBindings = []
            deployedEndpointPat = re.compile(r'.*deployedEndpoint=([^,]+),.*')
            for importName in AdminTask.listSCAImports(
                ['-moduleName', scaModuleName, '-applicationName',
                 appName]).splitlines():
                try:
                    importBinding = AdminTask.showSCAImportWSBinding([
                        '-moduleName', scaModuleName, '-applicationName',
                        appName, '-import', importName
                    ])
                    deployedEndpointMat = (
                        deployedEndpointPat.match(importBinding))
                    if deployedEndpointMat:
                        scaImportWSBindings.append([
                            scaModuleName, importName,
                            deployedEndpointMat.group(1)
                        ])
                except:
                    pass
            if scaImportWSBindings:
                manifest.extras['scaImportWSBindings'] = scaImportWSBindings
        except:
            pass
    applicationWSPolicySetAttachments = wdr.task.adminTaskAsDictList(
        AdminTask.getPolicySetAttachments(
            ['-applicationName', appName, '-attachmentType', 'application']))
    if applicationWSPolicySetAttachments:
        applicationWSPolicySetAttachmentList = []
        for att in applicationWSPolicySetAttachments:
            applicationWSPolicySetAttachmentList.append(
                [att['name'], att['pattern.0'],
                 att.get('binding', '')])
        manifest.extras['applicationWSPolicySetAttachments'] = (
            applicationWSPolicySetAttachmentList)
    clientWSPolicySetAttachments = wdr.task.adminTaskAsDictList(
        AdminTask.getPolicySetAttachments(
            ['-applicationName', appName, '-attachmentType', 'client']))
    if clientWSPolicySetAttachments:
        clientWSPolicySetAttachmentList = []
        for att in clientWSPolicySetAttachments:
            bindingName = att.get('binding', '')
            policyType = ''
            attributes = ''
            if bindingName != '':
                policyTypeList = AdminTask.listPolicyTypes([
                    '-bindingLocation',
                    [['application', appName], ['attachmentId', att['id']]],
                    '-attachmentType', 'client'
                ]).splitlines()
                if policyTypeList:
                    policyType = policyTypeList[0]
                    attributes = AdminTask.getBinding([
                        '-policyType', policyType, '-bindingLocation',
                        [['application', appName],
                         ['attachmentId', att['id']]], '-bindingName',
                        bindingName, '-attachmentType', 'client'
                    ])
            clientWSPolicySetAttachmentList.append([
                att['name'], att['pattern.0'], bindingName, policyType,
                attributes
            ])
        manifest.extras['clientWSPolicySetAttachments'] = (
            clientWSPolicySetAttachmentList)
    providerPolicySharingInfo = wdr.task.adminTaskAsDictList(
        AdminTask.getProviderPolicySharingInfo(['-applicationName', appName]))
    if providerPolicySharingInfo:
        providerPolicySharingInfoList = []
        for psi in providerPolicySharingInfo:
            providerPolicySharingInfoList.append([
                psi['resource'], psi['sharePolicyMethods'],
                psi.get('wsMexPolicySetName', ''),
                psi.get('wsMexPolicySetBinding', '')
            ])
        manifest.extras['providerPolicySharingInfo'] = (
            providerPolicySharingInfoList)
    for task in appManagement.getApplicationInfo(appName, prefs, None):
        taskProcessor = taskProcessors.get(task.name)
        if taskProcessor:
            taskProcessor['function'](Task(task), manifest,
                                      taskProcessor.get('columns'))
    for n in manifest.options.keys():
        v = manifest.options[n]
        if isinstance(v, ListType):
            v.sort()
    for n in manifest.extras.keys():
        v = manifest.extras[n]
        if isinstance(v, ListType):
            v.sort()
    return manifest
コード例 #55
0
ファイル: AudioPlayer.py プロジェクト: AndTH/JMRI
    def __init__(self):

        # Setup controls - buttons first
        self.playButton.preferredSize = self.refreshButton.preferredSize
        self.playButton.actionCommand = self.PLAY
        self.playButton.actionPerformed = self.whenButtonClicked
        self.pauseButton.preferredSize = self.refreshButton.preferredSize
        self.pauseButton.actionCommand = self.PAUSE
        self.pauseButton.actionPerformed = self.whenButtonClicked
        self.stopButton.preferredSize = self.refreshButton.preferredSize
        self.stopButton.actionCommand = self.STOP
        self.stopButton.actionPerformed = self.whenButtonClicked
        self.refreshButton.actionCommand = self.REFRESH
        self.refreshButton.actionPerformed = self.whenButtonClicked

        # Now combobox and text field
        self.sourceCombo.itemStateChanged = self.whenSourceChanged
        self.updateSourcesList()
        self.rangeSpinner.stateChanged = self.whenRangeChanged

        # Now sliders
        ticksMajor = int(self.posMinMax/4)
        ticksMinor = int(ticksMajor/5)
        labels = Hashtable(3)
        labels.put(-self.posMinMax, JLabel("Left"))
        labels.put(              0, JLabel("Centre"))
        labels.put( self.posMinMax, JLabel("Right"))
        self.positionXSlider.labelTable = labels
        self.positionXSlider.minimum = -self.posMinMax
        self.positionXSlider.maximum = self.posMinMax
        self.positionXSlider.majorTickSpacing = ticksMajor
        self.positionXSlider.minorTickSpacing = ticksMinor
        self.positionXSlider.paintTicks = True
        self.positionXSlider.paintLabels = True
        self.positionXSlider.snapToTicks = True
        self.positionXSlider.value = 0
        self.positionXSlider.stateChanged = self.whenSliderXChanged
        labels = Hashtable(3)
        labels.put(-self.posMinMax, JLabel("Behind"))
        labels.put(              0, JLabel("Centre"))
        labels.put( self.posMinMax, JLabel("In-front"))
        self.positionYSlider.labelTable = labels
        self.positionYSlider.minimum = -self.posMinMax
        self.positionYSlider.maximum = self.posMinMax
        self.positionYSlider.majorTickSpacing = ticksMajor
        self.positionYSlider.minorTickSpacing = ticksMinor
        self.positionYSlider.paintTicks = True
        self.positionYSlider.paintLabels = True
        self.positionYSlider.snapToTicks = True
        self.positionYSlider.value = 0
        self.positionYSlider.orientation = JSlider.VERTICAL
        self.positionYSlider.stateChanged = self.whenSliderYChanged
        labels = Hashtable(3)
        labels.put(-self.posMinMax, JLabel("Below"))
        labels.put(              0, JLabel("Centre"))
        labels.put( self.posMinMax, JLabel("Above"))
        self.positionZSlider.labelTable = labels
        self.positionZSlider.minimum = -self.posMinMax
        self.positionZSlider.maximum = self.posMinMax
        self.positionZSlider.majorTickSpacing = ticksMajor
        self.positionZSlider.minorTickSpacing = ticksMinor
        self.positionZSlider.paintTicks = True
        self.positionZSlider.paintLabels = True
        self.positionZSlider.snapToTicks = True
        self.positionZSlider.value = 0
        self.positionZSlider.orientation = JSlider.VERTICAL
        self.positionZSlider.stateChanged = self.whenSliderZChanged

        # Setup frame
        self.title = "Simple JMRI Audio Player"
        self.contentPane.layout = BoxLayout(self.contentPane, BoxLayout.Y_AXIS)

        # Add controls to frame - combo & buttons first
        p = JPanel(FlowLayout(FlowLayout.LEADING))
        p.add(self.sourceCombo)
        p.add(self.refreshButton)
        p.add(self.playButton)
        p.add(self.pauseButton)
        p.add(self.stopButton)
        #p.add(JLabel("Range"))
        #p.add(self.rangeSpinner)
        self.add(p)
        self.add(Box.createVerticalGlue())

        # Now sliders
        p = JPanel(FlowLayout(FlowLayout.LEADING))
        label = JLabel("Y Position")
        label.UI = VerticalLabelUI() # Default behaviour is anti-clockwise
        p.add(label)
        p.add(self.positionYSlider)
        p2 = JPanel()
        p2.layout = BoxLayout(p2, BoxLayout.Y_AXIS)
        p3 = JPanel()
        p3.add(JLabel("Range"))
        p3.add(self.rangeSpinner)
        p2.add(p3)
        #p2.add(Box.createVerticalGlue())
        p3 = JPanel()
        p3.layout = BoxLayout(p3, BoxLayout.Y_AXIS)
        label = JLabel("X Position")
        label.alignmentX = JLabel.CENTER_ALIGNMENT
        p3.add(label)
        p3.add(self.positionXSlider)
        p2.add(p3)
        p.add(p2)
        label = JLabel("Z Position")
        label.UI = VerticalLabelUI()
        p.add(label)
        p.add(self.positionZSlider)
        self.add(p)

        # Finally pack and show
        self.pack()
        self.show()