def netactivity(online): global netstate env = Environment.getInstance() if online: netstate = True env.active = True else: env = Environment.getInstance() netstate = False # # Function to shut down the client. Do some clean up and close sockets. # mqtt = PluginRegistry.getInstance("MQTTRelayService") # # # Tell others that we're away now # e = EventMaker() # goodbye = e.Event(e.BusClientState( # e.Id(env.uuid), # e.Type('proxy'), # e.State('leave') # )) # if mqtt: # mqtt.backend_mqtt.send_event(goodbye, qos=2) # mqtt.close() env.reset_requested = True env.active = False
def netactivity(online): global netstate env = Environment.getInstance() if online: netstate = True env.active = True else: env = Environment.getInstance() netstate = False # Function to shut down the client. Do some clean up and close sockets. try: mqtt = PluginRegistry.getInstance("MQTTClientHandler") # Tell others that we're away now e = EventMaker() goodbye = e.Event(e.ClientLeave(e.Id(env.uuid))) if mqtt: mqtt.send_event(goodbye, qos=1) except ValueError: pass finally: env.reset_requested = True env.active = False
def use_test_config(): Environment.reset() Environment.config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "..", "..", "test_conf") Environment.noargs = True oreg = ObjectRegistry.getInstance() # @UnusedVariable pr = PluginRegistry() # @UnusedVariable cr = PluginRegistry.getInstance("CommandRegistry") # @UnusedVariable
def __init__(self): env = Environment.getInstance() self.log = logging.getLogger(__name__) self.log.debug("initializing MQTT service provider") self.env = env self.__cr = None e = EventMaker() self.goodbye = e.Event(e.ClientLeave( e.Id(Environment.getInstance().uuid) ))
def available(): # This should always work try: env = Environment.getInstance() return env.config.get("core.otp") is not None except: return False
def process(self, obj, key, valDict): """ Detects whether this password hash was marked as locked or not """ ssl = Environment.getInstance().config.getboolean('http.ssl') valDict[key]['value'] = [ssl] return key, valDict
def main(): usage = """ Userspace tftp supplicant: create pxelinux configuration files based on external state information. """ Environment.config="fts.conf" Environment.noargs=True env = Environment.getInstance() cfg_path = env.config.get('pxelinux_cfg-path', default = os.sep.join((os.getcwd(), 'pxelinux.cfg'))) static_path = env.config.get('pxelinux_static-path', default = os.sep.join((os.getcwd(), 'pxelinux.static'))) if not os.access(cfg_path, os.F_OK): self.env.log.error("The pxelinux_cfg-path {path} does not exist!".format(path=cfg_path)) if not os.access(static_path, os.F_OK): self.env.log.error("The pxelinux_static-path {path} does not exist!".format(path=static_path)) # TODO: Use reliable method to start and control daemon process debug = "-d" p = subprocess.Popen( "{path}/fts-fuse.py -f {debug} {cfg_path}".format(path=os.getcwd(), debug=debug, cfg_path=cfg_path), shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE ) result = os.waitpid(p.pid, 0) sys.exit(result)
def use_test_config(request): env = Environment.getInstance() if has_dbus: # Enable DBus runner dr = DBusRunner() dr.start() PluginRegistry(component='gosa.client.module') # @UnusedVariable env.active = True def shutdown(): env.active = False # Wait for threads to shut down for t in env.threads: if hasattr(t, 'stop'): t.stop() if hasattr(t, 'cancel'): t.cancel() t.join(2) PluginRegistry.shutdown() if has_dbus: dr.stop() request.addfinalizer(shutdown)
def __init__(self): env = Environment.getInstance() self.log = logging.getLogger(__name__) self.log.debug("initializing AMQP service provider") self.env = env self.__cr = None self.__cmdWorker = None
def setPasswordRecoveryAnswers(self, user, object_dn, data): """ Set the password recovery answers for a user """ data = loads(data) # Do we have read permissions for the requested attribute env = Environment.getInstance() topic = "%s.objects.%s.attributes.%s" % (env.domain, "User", "passwordRecoveryHash") aclresolver = PluginRegistry.getInstance("ACLResolver") if not aclresolver.check(user, topic, "w", base=object_dn): self.__log.debug("user '%s' has insufficient permissions to write %s on %s, required is %s:%s" % ( user, "isLocked", object_dn, topic, "w")) raise ACLException(C.make_error('PERMISSION_ACCESS', topic, target=object_dn)) user = ObjectProxy(object_dn) method = user.passwordMethod # Try to detect the responsible password method-class pwd_o = self.get_method_by_method_type(method) if not pwd_o: raise PasswordException(C.make_error("PASSWORD_UNKNOWN_HASH", type=method)) # hash the new answers for idx, answer in data.items(): data[idx] = pwd_o.generate_password_hash(self.clean_string(answer), method) print("%s encrypted with %s as index %s => %s" % (self.clean_string(answer), method, idx, data[idx])) # Set the password and commit the changes user.passwordRecoveryHash = dumps(data) user.commit()
def setUserPassword(self, user, object_dn, password): """ Set a new password for a user """ # Do we have write permissions for the requested attribute env = Environment.getInstance() topic = "%s.objects.%s.attributes.%s" % (env.domain, "User", "userPassword") aclresolver = PluginRegistry.getInstance("ACLResolver") if not aclresolver.check(user, topic, "w", base=object_dn): self.__log.debug("user '%s' has insufficient permissions to write %s on %s, required is %s:%s" % ( user, "isLocked", object_dn, topic, "w")) raise ACLException(C.make_error('PERMISSION_ACCESS', topic, target=object_dn)) user = ObjectProxy(object_dn) method = user.passwordMethod # Try to detect the responsible password method-class pwd_o = self.get_method_by_method_type(method) if not pwd_o: raise PasswordException(C.make_error("PASSWORD_UNKNOWN_HASH", type=method)) # Generate the new password hash using the detected method pwd_str = pwd_o.generate_password_hash(password, method) # Set the password and commit the changes user.userPassword = pwd_str user.commit()
def accountUnlockable(self, user, object_dn): index = PluginRegistry.getInstance("ObjectIndex") # Do we have read permissions for the requested attribute env = Environment.getInstance() topic = "%s.objects.%s.attributes.%s" % (env.domain, "User", "isLocked") aclresolver = PluginRegistry.getInstance("ACLResolver") if not aclresolver.check(user, topic, "r", base=object_dn): self.__log.debug("user '%s' has insufficient permissions to read %s on %s, required is %s:%s" % ( user, "isLocked", object_dn, topic, "r")) raise ACLException(C.make_error('PERMISSION_ACCESS', topic, target=object_dn)) res = index.search({'dn': object_dn, 'userPassword': '******'}, {'userPassword': 1}) if len(res): hsh = res[0]['userPassword'][0] else: # No password hash -> cannot lock/unlock account return False # Try to detect the responsible password method-class pwd_o = self.detect_method_by_hash(hsh) if not pwd_o: # Could not identify password method return False return pwd_o.isUnlockable(hsh)
def __init__(self): env = Environment.getInstance() self.env = env self.log = logging.getLogger(__name__) # Read config values self.__puppet_user = env.config.get("puppet.user", default=env.config.get("client.user", default="gosa")) self.__target_dir = env.config.get("puppet.target", default="/etc/puppet") self.__puppet_command = env.config.get("puppet.command", default="/usr/bin/puppet") self.__report_dir = env.config.get("puppet.report-dir", default="/var/log/puppet") self.__base_dir = getpwnam(self.__puppet_user).pw_dir # Initialize if not already done if not self.puppetIsInitialized(): self.puppetInitialize(True) # Start log listener wm = pyinotify.WatchManager() # pylint: disable-msg=E1101 wm.add_watch(self.__report_dir, pyinotify.IN_CREATE, rec=True, auto_add=True) notifier = pyinotify.ThreadedNotifier(wm, PuppetLogWatcher()) env.threads.append(notifier) notifier.start()
def __init__(self): env = Environment.getInstance() self.env = env self.log = logging.getLogger(__name__) # Create icon cache directory self.spool = self.env.config.get("client.spool", default="/var/spool/gosa")
def setUp(self): """ Stuff to be run before every test """ Environment.config = "sample_test.conf" Environment.noargs = True self.env = Environment.getInstance() self.plugin = SampleModule()
def __init__(self): self.env = Environment.getInstance() self.log = logging.getLogger(__name__) self.ppd_dir = self.env.config.get("cups.spool", default="/tmp/spool") if not path.exists(self.ppd_dir): makedirs(self.ppd_dir) self.base_url = "%s/ppd-proxy/" % get_server_url()
def lockAccountPassword(self, user, object_dn): """ Locks the account password for the given DN """ # Do we have read permissions for the requested attribute env = Environment.getInstance() topic = "%s.objects.%s.attributes.%s" % (env.domain, "User", "userPassword") aclresolver = PluginRegistry.getInstance("ACLResolver") if not aclresolver.check(user, topic, "w", base=object_dn): self.__log.debug("user '%s' has insufficient permissions to write %s on %s, required is %s:%s" % ( user, "isLocked", object_dn, topic, "w")) raise ACLException(C.make_error('PERMISSION_ACCESS', topic, target=object_dn)) # Get the object for the given dn user = ObjectProxy(object_dn) # Check if there is a userPasswort available and set if not "userPassword" in user.get_attributes(): raise PasswordException(C.make_error("PASSWORD_NO_ATTRIBUTE")) if not user.userPassword: raise PasswordException(C.make_error("PASSWORD_NOT_AVAILABLE")) # Try to detect the responsible password method-class pwd_o = self.detect_method_by_hash(user.userPassword) if not pwd_o: raise PasswordException(C.make_error("PASSWORD_METHOD_UNKNOWN")) # Lock the hash and save it user.userPassword = pwd_o.lock_account(user.userPassword) user.commit()
def get_server_url(): """ Return the public URL of this GOsa server """ env = Environment.getInstance() gosa_server = env.config.get("jsonrpc.url")[0:-4] if env.config.get("jsonrpc.url") is not None else None if gosa_server is None: gosa_server = get_internal_server_url() return gosa_server
def __init__(self): conn = get_system_bus() dbus.service.Object.__init__(self, conn, '/com/gonicus/gosa/puppet') self.env = Environment.getInstance() self.log = logging.getLogger(__name__) self.logdir = self.env.config.get("puppet.report-dir", "/var/log/puppet") # Check puppet configuration config = ConfigParser.ConfigParser() config.read('/etc/puppet/puppet.conf') try: if config.get("main", "report", "false") != "true": raise OptionMissing("puppet has no reporting enabled") if config.get("main", "reportdir", "") != self.logdir: raise OptionMissing("reportdir configured in /etc/puppet/puppet.conf and %s do not match" % self.env.config.get('core.config')) if config.get("main", "reports", "") != "store_gosa": raise OptionMissing("storage module probably not compatible") except OptionMissing: self.hint("configuration section for puppet is incomplete") except ConfigParser.NoOptionError: self.hint("configuration section for puppet is incomplete")
def test_check_auth(): ldap_url = Environment.getInstance().config.get("ldap.url") retry_max = 3 retry_delay = 5 tls = "False" with mock.patch("gosa.backend.utils.ldap.Environment.getInstance") as m_env, \ mock.patch("gosa.backend.utils.ldap.ldap.ldapobject.ReconnectLDAPObject") as m_conn: # ldap.url, bind-user, bind-dn, bind-secret, retry-max, retry-delay, tls m_env.return_value.config.get.side_effect = [ldap_url, 'admin', None, 'secret', retry_max, retry_delay, tls] m_conn.return_value.search_s.return_value = [('fake-dn',)] assert check_auth("admin", "tester") is True assert m_conn.return_value.sasl_interactive_bind_s.called m_env.return_value.config.get.side_effect = [ldap_url, None, "bind-dn", 'secret', retry_max, retry_delay, tls] m_conn.return_value.search_s.return_value = [('fake-dn',), ('2nd-dn',)] assert check_auth("admin", "tester") is False m_conn.return_value.simple_bind_s.assert_called_with("bind-dn", "secret") m_env.return_value.config.get.side_effect = [ldap_url, None, None, None, retry_max, retry_delay, tls] m_conn.return_value.search_s.return_value = [] assert check_auth("admin", "tester") is False m_conn.return_value.simple_bind_s.assert_called_with() m_env.return_value.config.get.side_effect = [ldap_url, None, None, None, retry_max, retry_delay, tls] m_conn.return_value.search_s.side_effect = ldap.INVALID_CREDENTIALS("test error") assert check_auth("admin", "tester") is False m_conn.return_value.simple_bind_s.assert_called_with()
def get_internal_server_url(): env = Environment.getInstance() host = socket.getfqdn() if env.config.get("http.host", default="localhost") in ["0.0.0.0", "127.0.0.1"] \ else env.config.get("http.host", default="localhost") ssl = env.config.getboolean('http.ssl') protocol = "https" if ssl is True else "http" return "%s://%s:%s" % (protocol, host, env.config.get('http.port', default=8050))
def setSambaPassword(self, user, object_dn, password): """ Set a new samba-password for a user """ # Do we have read permissions for the requested attribute env = Environment.getInstance() topic = "%s.objects.%s.attributes.%s" % (env.domain, "User", "sambaNTPassword") aclresolver = PluginRegistry.getInstance("ACLResolver") if not aclresolver.check(user, topic, "w", base=object_dn): self.__log.debug("user '%s' has insufficient permissions to write %s on %s, required is %s:%s" % ( user, "isLocked", object_dn, topic, "w")) raise ACLException(C.make_error('PERMISSION_ACCESS', topic, target=object_dn)) topic = "%s.objects.%s.attributes.%s" % (env.domain, "User", "sambaLMPassword") aclresolver = PluginRegistry.getInstance("ACLResolver") if not aclresolver.check(user, topic, "w", base=object_dn): self.__log.debug("user '%s' has insufficient permissions to write %s on %s, required is %s:%s" % ( user, "isLocked", object_dn, topic, "w")) raise ACLException(C.make_error('PERMISSION_ACCESS', topic, target=object_dn)) # Set the password and commit the changes user = ObjectProxy(object_dn) user.sambaNTPassword = nthash.encrypt(password) user.sambaLMPassword = lmhash.encrypt(password) user.commit()
def __init__(self): self.env = Environment.getInstance() self.log = logging.getLogger(__name__) self.uuid = dmi_system("uuid") self.mac = self.get_mac_address() self.get_service() self.domain = socket.getfqdn().split('.', 1)[1]
def __init__(self): self.env = Environment.getInstance() self.ldap_handler = LDAPHandler.get_instance() self.nfs_root = self.env.config.get("nfs_root", default="/srv/nfsroot") self.nfs_opts = self.env.config.get("nfs_opts", default="nfs4") self.fai_flags = self.env.config.get("fai_flags", default="verbose,sshd,syslogd,createvt,reboot") self.union = self.env.config.get("union", default="unionfs")
def main(): """ Main programm which is called when the GOsa backend process gets started. It does the main forking os related tasks. """ # Set process list title os.putenv('SPT_NOENV', 'non_empty_value') setproctitle("gosa") # Initialize core environment env = Environment.getInstance() # create temporal credentials for mqtt env.core_uuid = str(uuid4()) env.core_key = str(uuid4()) if not env.base: env.log.critical("GOsa backend needs a 'core.base' do operate on") exit(1) env.log.info("GOsa %s is starting up" % VERSION) with warnings.catch_warnings(): warnings.simplefilter("ignore", category=sa_exc.SAWarning) mainLoop(env)
def __init__(self): env = Environment.getInstance() self.log = logging.getLogger(__name__) self.log.debug("initializing AMQP handler") self.env = env self.config = env.config # Initialize parser schema_root = etree.XML(PluginRegistry.getEventSchema()) schema = etree.XMLSchema(schema_root) self._parser = objectify.makeparser(schema=schema) # Evaluate username user = self.config.get("amqp.id", default=None) if not user: user = self.env.uuid password = self.config.get("amqp.key") # Load configuration self.url = parseURL(makeAuthURL(self.config.get('amqp.url'), user, password)) self.reconnect = self.config.get('amqp.reconnect', True) self.reconnect_interval = self.config.get('amqp.reconnect_interval', 3) self.reconnect_limit = self.config.get('amqp.reconnect_limit', 0) # Go for it self.start()
def __init__(self, path, name): self.env = Environment.getInstance() self.log = logging.getLogger(__name__) self.__base = path self.__path = os.path.join(path, self._prefix, name) self.__name = name self.load()
def setUp(self): """ Stuff to be run before every test """ Environment.config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "test-libinst.conf") Environment.noargs = True self.env = Environment.getInstance() self.mgr = LibinstManager() engine = self.env.getDatabaseEngine("repository") keyring = """-----BEGIN PGP PRIVATE KEY BLOCK----- Version: GnuPG v1.4.10 (GNU/Linux) lQHYBEx2RJ8BBADGAvwUiutOLO+OgkpWmOfNczRcEWZSja8jfZJFAHkSknq7t9lM FD0qYkjxnmGvi44cPmKu7Z2xkBxljyKK5pDOkCqB2QBUrXSnb3rg6/w9gX8Mh1er e8VZ/45sjxqwoUIPWWsrmEotQ9388KbEhdw14FQj/rai/Xa7rqYI6nVQSQARAQAB AAP6AyHggTljDsfnvu3ZQj/ihdj27A056XmOJ4elkobqNpfsdI9l8t3fy4dFvy28 8gKvnzG08uG1iyD1mnBho/sdytTKe7GMLDcHyWWBOl31WLKUzQFTOpQ6EjzKNyNl CGvwSKBm8u81BfNi7FpfgnVI733jdqZ8Lvq5znKRrK4WJdECANOaZn78oghTONUQ 1Fo6PgrjFkD337TR3Dm5tllp0Mlly9C9/N5CiTZj/0VLNyzT0tHVik8WEmF37bgY Zd2gA9kCAO+Oj6k9Bqs6uTjHFmT5NEGvoJVSd4Q+F4jDmT+U2yJEBUk1dHiRAcEr NcRU5VMbpBk9rbsmikX0oA1gavaNmfECAJi9uX99nb+dNWpqFqHxuDKaHapG9cKv AlI+btxIAzPFvqMuHMjFKn6T57D8QpIz1f7LdmlYKKOr3DRmaYOaJBClOrQ2QXV0 b2dlbmVyYXRlZCBLZXkgKEdlbmVyYXRlZCBieSBnbnVwZy5weSkgPGphbndAaG9t ZXI+iLgEEwECACIFAkx2RJ8CGy8GCwkIBwMCBhUIAgkKCwQWAgMBAh4BAheAAAoJ ELxLvnLaEqJwX2oD/2wAOYbZG68k7iDOqFI1TpQjlgRQKHNuvindjWrPjfgsDfZH kEhidYX1IRzgyhhLjrPDcB0RTcnjlXm9xOXJb3tcuyKWxi2CHMstdgTMHt6xb37o LcWMU6gayNYj7eMgCOFM6ywySRS81FC+PPnr147xbp5FwgmoPRK52MURsHJ+ =RwlJ -----END PGP PRIVATE KEY BLOCK-----""" self.assertTrue(self.mgr.addKeys(keyring)) self.helperAddRepositoryTypes() self.assertTrue(self.mgr.createDistribution("debian", "deb")) self.assertTrue(self.mgr.createRelease("debian", "lenny")) self.assertTrue(self.mgr.createRelease("debian", "lenny/5.0.4")) self.assertTrue(self.mgr.createRelease("debian", "squeeze"))
def __init__(self): super(MQTTClientHandler, self).__init__() e = EventMaker() self.goodbye = e.Event(e.ClientLeave( e.Id(Environment.getInstance().uuid) )) self.will_set("%s/client/%s" % (self.domain, self.env.uuid), self.goodbye, qos=1)
def process(self, obj, key, valDict): """ Detects whether this password hash was marked as locked or not """ ssl = Environment.getInstance().config.get('http.ssl', default=None) valDict[key]['value'] = [ssl and ssl.lower() in ["true", "yes", "on"]] return key, valDict
def __init__(self, autostart=True, host=None, port=None, keepalive=None): """ Construct a new MQTTClientHandler instance based on the configuration stored in the environment. @type env: Environment @param env: L{Environment} object """ self.log = logging.getLogger(__name__) self.log.debug("initializing MQTT client handler") self.env = Environment.getInstance() # Load configuration self.host = self.env.config.get('mqtt.host') if host is None else host if port is not None: self.port = port else: self.port = int(self.env.config.get('mqtt.port', default=1883)) \ if self.env.config.get('mqtt.port', default=1883) is not None else 1883 # Auto detect if possible if not self.host: svcs = find_bus_service() if svcs: self.host, self.port = svcs[0] # Bail out? if not self.host: self.log.error("no MQTT host available for bus communication") raise Exception("no MQTT host available") self.keep_alive = self.env.config.get('mqtt.keepalive', default=60) if keepalive is None else keepalive self.domain = self.env.domain domain_parts = socket.getfqdn().split('.', 1) self.dns_domain = domain_parts[1] if len(domain_parts) == 2 else "local" # Check if credentials are supplied if not self.env.config.get("jsonrpc.key") and not hasattr(self.env, "core_key"): raise Exception("no key supplied - please join the client") # Configure system if hasattr(self.env, "core_uuid") and hasattr(self.env, "core_key"): user = self.env.core_uuid key = self.env.core_key else: user = self.env.uuid key = self.env.config.get('jsonrpc.key') # Make proxy connection self.log.info("using service '%s:%s'" % (self.host, self.port)) self.__client = MQTTClient(self.host, port=self.port, keepalive=self.keep_alive) self.__client.authenticate(user, key) self.init_subscriptions() if autostart: # Start connection self.start()
def check_auth(user, password, get_dn=False): get = Environment.getInstance().config.get log = logging.getLogger(__name__) url = ldapurl.LDAPUrl(get("ldap.url")) bind_user = get('ldap.bind-user', default=None) bind_dn = get('ldap.bind-dn', default=None) bind_secret = get('ldap.bind-secret', default=None) conn = ldap.ldapobject.ReconnectLDAPObject( "%s://%s" % (url.urlscheme, url.hostport), retry_max=int(get("ldap.retry-max", default=3)), retry_delay=int(get("ldap.retry-delay", default=5))) # We only want v3 conn.protocol_version = ldap.VERSION3 # If no SSL scheme used, try TLS if get("ldap.tls", default="True").lower( ) == "true" and ldap.TLS_AVAIL and url.urlscheme != "ldaps": try: conn.start_tls_s() except ldap.PROTOCOL_ERROR as detail: log.debug("cannot use TLS, falling back to unencrypted session") try: # Get a connection if bind_dn: log.debug("starting simple bind using '%s'" % bind_dn) conn.simple_bind_s(bind_dn, bind_secret) elif bind_user: log.debug("starting SASL bind using '%s'" % bind_user) auth_tokens = ldap.sasl.digest_md5(bind_user, bind_secret) conn.sasl_interactive_bind_s("", auth_tokens) else: log.debug("starting anonymous bind") conn.simple_bind_s() # Search for the given user UID res = conn.search_s( url.dn, ldap.SCOPE_SUBTREE, filter_format( "(|(&(objectClass=registeredDevice)(deviceUUID=%s))(&(objectClass=person)(uid=%s)))", [user, user]), ['dn']) if len(res) == 1: dn = res[0][0] log.debug("starting simple bind using '%s'" % dn) conn.simple_bind_s(dn, password) return True if not get_dn else dn elif len(res) > 1: log.error("LDAP authentication failed: user %s not unique" % user) else: log.error("LDAP authentication failed: user %s not found" % user) except ldap.INVALID_CREDENTIALS as detail: log.error("LDAP authentication failed: %s" % str(detail)) return False
def get_server_url(): """ Return the public URL of this GOsa server """ env = Environment.getInstance() gosa_server = env.config.get("jsonrpc.url")[0:-4] if env.config.get( "jsonrpc.url") is not None else None if gosa_server is None: gosa_server = get_internal_server_url() return gosa_server
def __init__(self): env = Environment.getInstance() self.env = env self.__dr = DBusRunner.get_instance() self.__bus = None # Register for resume events zope.event.subscribers.append(self.__handle_events)
def __init__(self): env = Environment.getInstance() self.log = logging.getLogger(__name__) self.log.debug("initializing scheduler service") self.env = env self.sched = Scheduler() self.sched.daemonic = True self.sched.add_jobstore(RAMJobStore(), 'ram', True)
def setUp(self): super(MQTTRelayServiceTestCase, self).setUp() self.env = Environment.getInstance() self.env.core_uuid = str(uuid.uuid4()) self.service = MQTTRelayService() self.service.serve() PluginRegistry.modules["ACLResolver"] = mock.MagicMock() PluginRegistry.modules["ObjectIndex"] = mock.MagicMock()
def __init__(self): self.env = Environment.getInstance() # Load container mapping from object Factory factory = ObjectFactory.getInstance() self.containers = [] for ot, info in factory.getObjectTypes().items(): if 'container' in info: self.containers.append(ot)
def __init__(self): env = Environment.getInstance() self.env = env self.log = logging.getLogger(__name__) # Register ourselfs for bus changes on org.gosa dr = DBusRunner.get_instance() self.bus = dr.get_system_bus() self.bus.watch_name_owner("org.gosa", self.__dbus_proxy_monitor)
def initialize(self): env = Environment.getInstance() default = PluginRegistry.getInstance('HTTPService').get_gui_uri()[1] path = frontend_path if env.config.get("gui.debug", "false") == "false": # pragma: nocover path = os.path.join(frontend_path, 'gosa', 'build') super(GuiPlugin, self).initialize(path, default)
def __init__(self): env = Environment.getInstance() self.env = env self.__dr = DBusRunner.get_instance() self.__bus = None self.__notify_backend = env.config.getboolean("client.dbus-login", default=True) # Register for resume events zope.event.subscribers.append(self.__handle_events)
def __init__(self): env = Environment.getInstance() self.log = logging.getLogger(__name__) self.log.info("initializing HTTP service provider") self.env = env self.srv = None self.ssl = False self.host = None self.scheme = None self.port = None
def __init__(self): conn = get_system_bus() dbus.service.Object.__init__(self, conn, '/org/gosa/service') self.env = Environment.getInstance() self.log = logging.getLogger(__name__) self.systembus = dbus.SystemBus() systemd_obj = self.systembus.get_object("org.freedesktop.systemd1", "/org/freedesktop/systemd1") self.systemd = dbus.Interface(systemd_obj, "org.freedesktop.systemd1.Manager")
def __init__(self, path, callback): # Initialize the plugin and set path self.bp = self.path = path self.callback = callback self.env = Environment.getInstance() self.log = logging.getLogger(__name__) # Start the files system surveillance thread now self.__start()
def __init__(self, _id, what=None, user=None, session_id=None): schema = etree.XMLSchema( file=resource_filename("gosa.backend", "data/workflow.xsd")) parser = objectify.makeparser(schema=schema) self.env = Environment.getInstance() self.parent = self self.uuid = _id self.dn = self.env.base self.__xml_parsing = XmlParsing('Workflows') self.__validator = Validator(self) self.__attribute_config = {} self.__user = user self.__session_id = session_id self.__log = logging.getLogger(__name__) self.__attribute_type = {} for entry in pkg_resources.iter_entry_points("gosa.object.type"): mod = entry.load() self.__attribute_type[mod.__alias__] = mod() self._path = self.env.config.get("core.workflow_path", "/var/lib/gosa/workflows") self._xml_root = objectify.parse( os.path.join(self._path, _id, "workflow.xml"), parser).getroot() self.__attribute = {key: None for key in self.get_attributes()} self.__method_map = { "commit": None, "get_templates": None, "get_translations": None, } self.__fill_method_map() if what is not None: # load object and copy attribute values to workflow try: self.__reference_object = ObjectProxy(what) self.__skip_refresh = True # set the reference dn if possible if 'reference_dn' in self.__attribute: setattr(self, 'reference_dn', what) # copy all other available attribute values to workflow object for key in self.__attribute: if hasattr(self.__reference_object, key) and getattr( self.__reference_object, key) is not None: setattr(self, key, getattr(self.__reference_object, key)) self.__skip_refresh = False except Exception as e: # could not open the reference object self.__log.error(e)
def test_clientLeave(self): service = PluginRegistry.getInstance("MQTTRPCService") e = EventMaker() goodbye = e.Event(e.ClientLeave(e.Id("fake_uuid"))) data = etree.tostring(goodbye).decode('utf-8') with mock.patch.object(PluginRegistry.getInstance("BackendRegistry"), "unregisterBackend") as m: service.handle_request( "%s/proxy" % Environment.getInstance().domain, data) m.assert_called_with("fake_uuid")
def test_send_event(self): mqtt = MQTTClientHandler() env = Environment.getInstance() with mock.patch("gosa.client.mqtt.MQTTHandler.send_event") as m: mqtt.send_event("test-data") m.assert_called_with("test-data", "%s/client/%s" % (env.domain, env.uuid), qos=0) m.reset_mock() mqtt.send_event("test-data", topic="test/topic") m.assert_called_with("test-data", "test/topic", qos=0)
def __init__(self): """ Construct a new ClientService instance based on the configuration stored in the environment. """ env = Environment.getInstance() self.log = logging.getLogger(__name__) self.log.info("initializing client service") self.env = env self.__cr = None self.mqtt = None
def __init__(self): self.__shells = {} # Use a shell source file env = Environment.getInstance() source = env.config.get('posix.shells', default="/etc/shells") with open(source) as f: self.__shells = list( filter(lambda y: not y.startswith("#"), [x.strip() for x in f.read().split("\n")]))
def get_local_ppd_path(url): server_url = get_server_url() if url[0:len(server_url)] == server_url: http_part = "%s/ppd/modified/" % get_server_url() dir = Environment.getInstance().config.get("cups.spool", default="/tmp/spool") return "%s/%s" % (dir, url[len(http_part):]) elif url[0:1] == "/": # is already a local path return url return None
def __init__(self): self.env = Environment.getInstance() self.log = logging.getLogger(__name__) # Load container mapping from object Factory factory = ObjectFactory.getInstance() self.containers = [] for ot, info in factory.getObjectTypes().items(): if 'container' in info: self.containers.append(ot) self.__fuzzy_similarity_threshold = self.env.config.getfloat( "backend.fuzzy-threshold", default=0.3)
def initialize(self): env = Environment.getInstance() default = PluginRegistry.getInstance('HTTPService').get_gui_uri()[1] path = frontend_path if env.config.get("gui.debug", "false") == "true": # pragma: nocover path = os.path.realpath( os.path.join( pkg_resources.resource_filename("gosa.plugins.gui", "data"), '..', '..', '..', '..', '..', 'frontend' ) ) super(GuiPlugin, self).initialize(path, default)
def test_get_connection(self): handler = LDAPHandler() with pytest.raises(LDAPException),\ mock.patch("gosa.backend.utils.ldap.LDAPHandler.connection_usage", new_callable=mock.PropertyMock, return_value=[True]): handler.get_connection() del handler ldap_url = Environment.getInstance().config.get("ldap.url") retry_max = 3 retry_delay = 5 tls = "False" with mock.patch("gosa.backend.utils.ldap.Environment.getInstance") as m_env, \ mock.patch("gosa.backend.utils.ldap.ldap.ldapobject.ReconnectLDAPObject") as m_conn: # ldap.url, bind-user, bind-dn, bind-secret, pool-size, retry-max, retry-delay, tls m_env.return_value.config.get.side_effect = [ ldap_url, 'admin', None, 'secret', 10, retry_max, retry_delay, tls ] handler = LDAPHandler() handler.get_connection() assert m_conn.return_value.sasl_interactive_bind_s.called del handler m_env.return_value.config.get.side_effect = [ ldap_url, None, "bind-dn", 'secret', 10, retry_max, retry_delay, tls ] handler = LDAPHandler() handler.get_connection() m_conn.return_value.simple_bind_s.assert_called_with( "bind-dn", "secret") del handler m_env.return_value.config.get.side_effect = [ ldap_url, None, None, None, 10, retry_max, retry_delay, tls ] handler = LDAPHandler() handler.get_connection() m_conn.return_value.simple_bind_s.assert_called_with() del handler m_conn.reset_mock() m_env.return_value.config.get.side_effect = [ ldap_url, None, None, None, 10, retry_max, retry_delay, tls ] m_conn.return_value.simple_bind_s.side_effect = ldap.INVALID_CREDENTIALS( "test error") handler = LDAPHandler() with mock.patch.object(handler, "log") as m_log: handler.get_connection() assert m_log.error.called del handler
def __init__(self): env = Environment.getInstance() self.log = logging.getLogger(__name__) self.log.debug("initializing scheduler") self.env = env self.sched = Scheduler() self.sched.add_jobstore( SQLAlchemyJobStore( engine=self.env.getDatabaseEngine("backend-database")), "default") self.sched.add_jobstore(RAMJobStore(), 'ram', True)
def __init__(self): self.env = Environment.getInstance() self.log = logging.getLogger(__name__) self.uuid = dmi_system("uuid") self.mac = self.get_mac_address() try: self.domain = socket.getfqdn().split('.', 1)[1] except IndexError: self.log.warning("system has no proper DNS domain") self.domain = socket.getfqdn().split('.', 1)[0] + ".local" self.get_service()
def __init__(self): env = Environment.getInstance() self.env = env self.log = logging.getLogger(__name__) # Register ourselfs for bus changes on org.gosa dr = DBusRunner.get_instance() self.bus = dr.get_system_bus() self.bus.watch_name_owner("org.gosa", self.__dbus_proxy_monitor) # Create icon cache directory self.spool = env.config.get("client.spool", default="/var/spool/gosa")
def render(data): env = Environment.getInstance() cache_path = env.config.get('user.image-path', default="/var/lib/gosa/images") if os.path.exists( os.path.join(cache_path, data['_uuid'], "jpegPhoto", "0", "64.jpg")): return "/images/%s/jpegPhoto/0/64.jpg?c=%s" % ( data['_uuid'], data["_last_changed"]) return "@Ligature/user"
def __init__(self): self.env = Environment.getInstance() # Remove old lock if exists if GlobalLock.exists("scan_index"): GlobalLock.release("scan_index") self.log = logging.getLogger(__name__) self.log.info("initializing object index handler") self.factory = ObjectFactory.getInstance() # Listen for object events zope.event.subscribers.append(self.__handle_events)
def netactivity(online): global netstate env = Environment.getInstance() if online: netstate = True env.active = True else: env = Environment.getInstance() netstate = False # Function to shut down the client. Do some clean up and close sockets. mqtt = PluginRegistry.getInstance("MQTTClientHandler") # Tell others that we're away now e = EventMaker() goodbye = e.Event(e.ClientLeave(e.Id(env.uuid))) if mqtt: mqtt.send_event(goodbye) mqtt.close() env.reset_requested = True env.active = False