def test_from_netlink_source_udev(self, context):
     monitor = Monitor.from_netlink(context)
     assert monitor._as_parameter_
     assert not monitor.started
     monitor = Monitor.from_netlink(context, source='udev')
     assert monitor._as_parameter_
     assert not monitor.started

 def test_from_netlink_source_udev_mock(self, context):
     calls = {'udev_monitor_new_from_netlink':
              [(context, b'udev'), (context, b'udev')]}
     with pytest.calls_to_libudev(calls):
         libudev.udev_monitor_new_from_netlink.return_value = sentinel.monitor
         monitor = Monitor.from_netlink(context)
         assert monitor._as_parameter_ is sentinel.monitor
         assert not monitor.started
         monitor = Monitor.from_netlink(context, 'udev')
         assert monitor._as_parameter_ is sentinel.monitor
         assert not monitor.started

 def test_from_socket_mock(self, context, socket_path):
     socket_path = str(socket_path)
     new_from_socket = 'udev_monitor_new_from_socket'
     with pytest.patch_libudev(new_from_socket) as new_from_socket:
         new_from_socket.return_value = mock.sentinel.pointer
         monitor = Monitor.from_socket(context, socket_path)
         new_from_socket.assert_called_with(
             context, socket_path.encode(sys.getfilesystemencoding()))
         assert monitor._as_parameter_ is mock.sentinel.pointer
         Monitor.from_socket(context, 'foobar')
         new_from_socket.assert_called_with(context, b'foobar')
         assert isinstance(new_from_socket.call_args[0][1], bytes)

 def test_from_netlink_source_udev_mock(self, context):
     funcname = 'udev_monitor_new_from_netlink'
     spec = lambda c, s: None
     with mock.patch.object(context._libudev, funcname,
                            autospec=spec) as func:
         func.return_value = mock.sentinel.monitor
         monitor = Monitor.from_netlink(context)
         assert monitor._as_parameter_ is mock.sentinel.monitor
         assert not monitor.started
         func.assert_called_once_with(context, b'udev')
         func.reset_mock()
         monitor = Monitor.from_netlink(context, 'udev')
         assert monitor._as_parameter_ is mock.sentinel.monitor
         assert not monitor.started
         func.assert_called_once_with(context, b'udev')

    def disk_src(self):
        try:
            from pyudev.glib import MonitorObserver

            def device_event(observer, device):
                print 'event {0} on device {1}'.format(device.action, device)
                if device.action == "add":
                    manager.disk_mnt(context)
                elif device.action == "remove":
                    manager.disk_umnt(device)
        except:
            from pyudev.glib import GUDevMonitorObserver as MonitorObserver

            def device_event(observer, action, device):
                print 'event {0} on device {1}'.format(action, device)
                if action == "add":
                    manager.disk_mnt(context)
                elif action == "remove":
                    manager.disk_umnt(device)
        context = Context()
        manager = Storage(self.cfg, self.log)
        monitor = Monitor.from_netlink(context)
        monitor.filter_by(subsystem='block', device_type='partition')
        observer = MonitorObserver(monitor)
        observer.connect('device-event', device_event)
        monitor.start()
        glib.MainLoop().run()

 def __init__(self):
     self.context = Context()
     self.monitor = Monitor.from_netlink(self.context)
     self.monitor.filter_by(subsystem='usb')
     self.observer = MonitorObserver(
         self.monitor, callback=self.event_handler, name="blahblah")
     self.observer.daemon = True

def main2():
    context = Context()
    monitor = Monitor.from_netlink(context)
    monitor.filter_by(subsystem='input')
    observer = MonitorObserver(monitor)
    observer.connect('device-event', device_event)
    monitor.start()

 def __init__(self, callback):
     # set up udev device monitor
     context = Context()
     self._monitor = Monitor.from_netlink(context)
     self._monitor.filter_by(subsystem='sound')
     self._observer = MonitorObserver(self._monitor)
     self._observer.connect('device-event', callback)

def initialize():
	context = Context()
	monitor = Monitor.from_netlink(context)
	monitor.filter_by(subsystem='tty')
	observer = MonitorObserver(monitor, callback=print_device_event, name = 'monitor-observer')
	observer.daemon
	observer.start()

def monitor_background():
    c = Context()

    monitor = Monitor.from_netlink(c)
    monitor.filter_by("block", "disk")

    obs = MonitorObserver(monitor, device_event)
    obs.start()

def start_udev_monitoring():
    #Setting up Linux UDEV monitoring in a separate thread
    context = Context()
    monitor = Monitor.from_netlink(context)
    monitor.filter_by(subsystem='block')
    observer = MonitorObserver(monitor, callback=find_garmin, name='monitor-observer')
    observer.daemon = True
    observer.start()

	def watch(self, filtername, callback):
		context = Context()
		monitor = Monitor.from_netlink(context)

		monitor.filter_by(filtername)

		observer = MonitorObserver(monitor, callback=callback, name="monitor-observer")
		observer.start()

def set_monitor_func(func):
    global HANDLER
    HANDLER = func
    udev_context = Context()
    monitor = Monitor.from_netlink(udev_context)
    monitor.filter_by('block')
    observer = MonitorObserver(monitor, log_event)
    observer.start()

def _assert_from_netlink_called(context, *args):
    new_from_netlink = 'udev_monitor_new_from_netlink'
    with pytest.patch_libudev(new_from_netlink) as new_from_netlink:
        source = args[0].encode('ascii') if args else b'udev'
        new_from_netlink.return_value = mock.sentinel.pointer
        monitor = Monitor.from_netlink(context, *args)
        new_from_netlink.assert_called_with(context, source)
        assert isinstance(new_from_netlink.call_args[0][1], bytes)
        assert monitor._as_parameter_ is mock.sentinel.pointer

 def test_enable_receiving_bound_socket(self, context, socket_path):
     sock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
     # cause an error by binding the socket, thus testing error handling in
     # this method
     sock.bind(str(socket_path))
     monitor = Monitor.from_socket(context, str(socket_path))
     with pytest.raises(EnvironmentError) as exc_info:
         monitor.enable_receiving()
     pytest.assert_env_error(exc_info.value, errno.EADDRINUSE, str(socket_path))

def monitor():
    context = Context()
    monitor = Monitor.from_netlink(context)
    monitor.filter_by(subsystem='usb')  
    observer = MonitorObserver(monitor)
    observer.connect('device-removed', remove_event)
    observer.connect('device-added', add_event)
    monitor.start()
    glib.MainLoop().run()

    def _listenOnUsb(self):
        context = Context()
        monitor = Monitor.from_netlink(context)

        monitor.filter_by(subsystem="usb")
        observer = MonitorObserver(monitor)
        observer.connect("device-event", self._deviceEvent)
        monitor.start()

        glib.MainLoop().run()

def monitor(callback, *device_filters):
	m = _Monitor.from_netlink(_Context())
	m.filter_by(subsystem='hidraw')
	for action, device in m:
		hid_dev = device.find_parent('hid')
		if hid_dev:
			for filter in device_filters:
				dev_info = _match(device, hid_dev, *filter)
				if dev_info:
					callback(action, dev_info)
					break

    def _get_future_devices(self, context):
        """Return a generator yielding new devices."""
        monitor = Monitor.from_netlink(context)
        monitor.filter_by("hidraw")
        monitor.start()

        self._scanning_log_message()
        for device in iter(monitor.poll, None):
            if device.action == "add":
                yield device
                self._scanning_log_message()

def loopForDevices():
    context = Context()
    monitor = Monitor.from_netlink(context)
    
    monitor.filter_by(subsystem='block',device_type='partition')
#     monitor.filter_by(subsystem='usb')
    observer = MonitorObserver(monitor)
    
    observer.connect('device-event', device_event)
    monitor.start()
    glib.MainLoop().run()