class Client(object):
    def __init__(self, specFilename, exchange='signals'):
        self.exchange = exchange
        spec = txamqp.spec.load(specFilename)

        delegate = TwistedDelegate()
        self.clientConnected = ClientCreator(reactor, AMQClient,
                                             delegate=delegate, vhost="/",
                                     spec=spec).connectTCP("localhost", 5672)
        self.conn = None
        self.chan = None
        self.finishLock = DeferredLock()

    @inlineCallbacks
    def finishChannelOpen(self):
        yield self.finishLock.acquire()
        if self.conn is None:
            print "opening connection for", self
            self.conn = yield self.clientConnected

            authentication = {"LOGIN": "guest", "PASSWORD": "guest"}
            yield self.conn.start(authentication)

        if self.chan is None:
            self.chan = yield self.conn.channel(1)
            yield self.chan.channel_open()
            yield self.newChan()
            print "made channel for", self
        self.finishLock.release()
            
    def newChan(self):
        # called once when the new channel is opened
        return succeed(None)

class NotificationConnector(object):
    """Provide ready-to-use AMQP channels."""

    def __init__(self, service, clock=reactor):
        """
        @param service: An object implementing the same whenConnected() API as
            the twisted.application.internet.ClientService class.
        @param clock: An object implementing IReactorTime.
        """
        self._service = service
        self._clock = clock
        self._channel = None
        self._channel_lock = DeferredLock()

    @inlineCallbacks
    def __call__(self):
        """
        @return: A deferred firing with a ready-to-use txamqp.protocol.Channel.
        """
        # Serialize calls, in order to setup new channels only once.
        yield self._channel_lock.acquire()
        try:
            if self._channel and self._channel.client.closed:
                # If we have a client but it's closed, let's wait for it to be
                # fully disconnected and spin a reactor iteration to give
                # change to the AMQClient.connectionLost callback chain to
                # settle (in particular our ClientService will be notified and
                # will start connecting again).
                yield self._channel.client.disconnected.wait()
                yield deferLater(self._clock, 0, lambda: None)

            client = yield self._service.whenConnected()
            channel = yield client.channel(1)
            # Check if we got a new channel, and initialize it if so.
            if channel is not self._channel:
                self._channel = channel
                yield self._channel.channel_open()
                # This tells the broker to deliver us at most one message at
                # a time to support using multiple processes (e.g. in a
                # load-balanced/HA deployment). If NotificationSource.get()
                # gets called against the same UUID first by process A and then
                # when it completes by process B, we're guaranteed that process
                # B will see the very next message in the queue, because
                # process A hasn't fetched any more messages than the one it
                # received. See #729140.
                yield self._channel.basic_qos(prefetch_count=1)
        finally:
            self._channel_lock.release()
        returnValue(self._channel)

class emailer( LabradServer ):
    name = 'Email Server'
    
    @inlineCallbacks
    def initServer( self ):
        self.username, self.fromaddr, self.password = yield self.getInfoReg()
        self.password = base64.b64decode(self.password)
        self.toaddrs = {}
        self.smtp = 'smtp.gmail.com:587'
        self.sending = DeferredLock()
    
    @inlineCallbacks
    def getInfoReg(self):
        reg = self.client.registry
        yield reg.cd(['Servers','Email Server'])
        username = yield reg.get('username')
        fromaddr = yield reg.get('address')
        password = yield reg.get('password')
        returnValue([username,fromaddr,password])
        
    @setting(0, "Set Recipients", recepients = '*s', returns = '')
    def setRecepients(self, c, recepients):
        """Set the recipients of the email as a list of strings of email addresses"""
        self.toaddrs[c.ID] = recepients
    
    @setting(1, "Send", subject = 's', message = 's', returns = '')
    def selectDP(self, c, subject, message):
        """Select Double Pass in the current context"""
        if not self.toaddrs[c.ID]: raise Exception("Recipients not set")
        yield self.sending.acquire()  
        session = smtplib.SMTP(self.smtp)
        session.starttls()
        session.login(self.username,self.password)
        toaddrs = self.toaddrs[c.ID]
        msg = MIMEMultipart()
        msg['From'] = self.fromaddr
        msg['To'] = COMMASPACE.join(toaddrs)
        msg['Subject'] = subject
        msg.attach(MIMEText(message, 'plain'))    
        session.sendmail(self.fromaddr, toaddrs, msg.as_string())
        session.quit()
        self.sending.release()
    
    def initContext(self, c):
        """Initialize a new context object."""
        pass
    
    def expireContext(self, c):
        del(self.toaddrs[c.ID])

class Pulser_729(LabradServer):
    
    name = 'Pulser_729'
       
    def initServer(self):
        self.api  = api()
        self.inCommunication = DeferredLock()
        self.initializeBoard()
    
    def initializeBoard(self):
        connected = self.api.connectOKBoard()
        if not connected:
            raise Exception("Pulser Not Found")
    
    @setting(0, 'Reset DDS', returns = '')
    def resetDDS(self , c):
        """
        Reset the ram position to 0
        """
        yield self.inCommunication.acquire()
        yield deferToThread(self.api.resetAllDDS)
        self.inCommunication.release()
        
    @setting(1, "Program DDS", program = '*(is)', returns = '')
    def programDDS(self, c, program):
        """
        Programs the DDS, the input is a tuple of channel numbers and buf objects for the channels
        """
        yield self.inCommunication.acquire()
        yield deferToThread(self._programDDSSequence, program)
        self.inCommunication.release()
    
    @setting(2, "Reinitialize DDS", returns = '')
    def reinitializeDDS(self, c):
        """
        Reprograms the DDS chip to its initial state
        """
        yield self.inCommunication.acquire()
        yield deferToThread(self.api.initializeDDS)
        self.inCommunication.release()
    
    def _programDDSSequence(self, program):
        '''takes the parsed dds sequence and programs the board with it'''
        for chan, buf in program:
            self.api.setDDSchannel(chan)
            self.api.programDDS(buf)
        self.api.resetAllDDS()
    
    def wait(self, seconds, result=None):
        """Returns a deferred that will be fired later"""
        d = Deferred()
        reactor.callLater(seconds, d.callback, result)
        return d

    def acquire(self, timeout=None):
        """
        This method operates the same as :meth:`DeferredLock.acquire` does
        except it requires a timeout argument.

        :param int timeout:
            The number of seconds to wait before timing out.

        :raises LockTimeoutError:
            Raised if the timeout was reached before we could acquire
            the lock.
        """
        assert timeout is None \
            or isinstance(timeout, (int, float)) and timeout > 0

        lock = DeferredLock.acquire(self)
        if timeout is None:
            return lock

        # Schedule a call to trigger finished.errback() which will raise
        # an exception.  If lock finishes first however cancel the timeout
        # and unlock the lock by calling finished.
        finished = Deferred()
        lock.addCallback(
            self._cancel_timeout,
            reactor.callLater(timeout, self._timeout, finished))
        lock.addCallback(self._call_callback, finished)

        return finished

    def __init__(self, omegleProto):
        """
        Initializes an L{OmegleBot}.

        @param omegleProto: an instance of a protocol that implements:
            * typingCallback: when the stranger is typing
            * stoppedTypingCallback: stranger no longer typing
            * disconnectCallback: stranger OR bot has disconnected
            * messageCallback: when the stranger has sent us a message
            * recaptchaFailedCallback: when our submitted captcha fails
            * recaptchaRequiredCallback: when omegle requires a captcha
            * connectCallback: when we have found a stranger
            * waitingCallback: when we are waiting for a stranger
        """

        for callback_name in ('typingCallback',
                              'stoppedTypingCallback',
                              'disconnectCallback',
                              'messageCallback',
                              'recaptchaFailedCallback',
                              'recaptchaRequiredCallback',
                              'connectCallback',
                              'waitingCallback',
                             ):
            setattr(self, callback_name, getattr(omegleProto, callback_name, None))

        self.status = DISCONNECTED
        self.server = None
        self.id = None
        self.lock = DeferredLock()
        self.activeRequests = set()
        self.challenge = None
        self.image = None

 def initServer(self):
     self.api  = api()
     self.channelDict = hardwareConfiguration.channelDict
     self.collectionTime = hardwareConfiguration.collectionTime
     self.collectionMode = hardwareConfiguration.collectionMode
     self.sequenceType = hardwareConfiguration.sequenceType
     self.isProgrammed = hardwareConfiguration.isProgrammed
     self.timeResolution = float(hardwareConfiguration.timeResolution)
     self.ddsDict = hardwareConfiguration.ddsDict
     self.timeResolvedResolution = hardwareConfiguration.timeResolvedResolution
     self.remoteChannels = hardwareConfiguration.remoteChannels
     self.collectionTimeRange = hardwareConfiguration.collectionTimeRange
     self.sequenceTimeRange = hardwareConfiguration.sequenceTimeRange
     self.haveSecondPMT = hardwareConfiguration.secondPMT
     self.haveDAC = hardwareConfiguration.DAC
     self.inCommunication = DeferredLock()
     self.clear_next_pmt_counts = 0
     self.hwconfigpath = os.path.dirname(inspect.getfile(hardwareConfiguration))
     print self.hwconfigpath
     #LineTrigger.initialize(self)
     #self.initializeBoard()
     #yield self.initializeRemote()
     #self.initializeSettings()
     #yield self.initializeDDS()
     self.ddsLock = True
     self.listeners = set()

    def __init__(self, config=None):
        ApplicationSession.__init__(self, config)

        global live
        live = self

        self.logger = logging.getLogger('Live')

        self.logger.info("Config: %s", config)

        self.account_id = config.extra['authid']
        self.secret = config.extra['secret']

        if '-' not in self.account_id:
            self.account_id = "local-%s" % self.account_id

        self.authid = '%s:%s' % (self.account_id, self.secret[-7:])

        self.joined = False
        self.lock = DeferredLock()

        self.checks = {}
        self.workers = {}

        self.CallOptions = CallOptions()

 def __init__(self, priority):
     self._lock = DeferredLock()
     self.priority = str(priority)
     self.is_shutdown = False
     self.state_pub = state_publisher.StatePublisher(())
     self.flush()
     reactor.addSystemEventTrigger('before', 'shutdown', self._shutdown)

    def __init__(self, publisher, ignoreBuilders=None, send_logs=False,
            max_connect_time=600, max_idle_time=300, heartbeat_time=900):
        self.publisher = publisher
        self.send_logs = send_logs

        self.ignoreBuilders = []
        if ignoreBuilders:
            for i in ignoreBuilders:
                if isinstance(i, basestring):
                    self.ignoreBuilders.append(re.compile(i))
                else:
                    assert hasattr(i, 'match') and callable(i.match)
                    self.ignoreBuilders.append(i)
        self.watched = []

        self.max_connect_time = max_connect_time
        self.max_idle_time = max_idle_time
        self.heartbeat_time = heartbeat_time

        self._disconnect_timer = None
        self._idle_timer = None

        # Lock to make sure only one thread is active at a time
        self._thread_lock = DeferredLock()

        # Set up heartbeat
        self._heartbeat_loop = LoopingCall(self.heartbeat)

        StatusPush.__init__(self, PulseStatus.pushEvents, filter=False)

 def __init__(self, cxn, context, dataset):
     super(Dataset, self).__init__()
     self.accessingData = DeferredLock()
     self.cxn = cxn
     self.context = context # context of the first dataset in the window
     self.dataset = dataset
     self.data = None
     self.setupDataListener(self.context)

 def initServer(self):
     self.api_dac  = api_dac()
     self.inCommunication = DeferredLock()
     connected = self.api_dac.connectOKBoard()
     if not connected:
         raise Exception ("Could not connect to DAC")
     self.d = yield self.initializeDAC()
     self.listeners = set()     

 def __init__(self, name, conf):
     _log.info("CF_INIT %s", name)
     self.name, self.conf = name, conf
     self.channel_dict = defaultdict(list)
     self.iocs = dict()
     self.client = None
     self.currentTime = getCurrentTime
     self.lock = DeferredLock()

    def __init__(self, consumer):
        self.consumer = consumer
        assert IConsumer.implementedBy(consumer.__class__)

        self._producers = []

        self._sendingLock = DeferredLock()
        self._localHeaderLength = 0
        self._centralDirectoryLength = 0

 def initServer(self):
     self.channelDict =  hardwareConfiguration.channelDict
     self.collectionTime = hardwareConfiguration.collectionTime
     self.collectionMode = hardwareConfiguration.collectionMode
     self.sequenceType = hardwareConfiguration.sequenceType
     self.isProgrammed = hardwareConfiguration.isProgrammed
     self.inCommunication = DeferredLock()
     self.connectOKBoard()
     self.listeners = set()

    def __init__(self):
        # so parts of this instance are accessible elsewhere
        assert "agent" not in config
        config["agent"] = self
        self.services = {}
        self.register_shutdown_events = False
        self.last_free_ram_post = time.time()
        self.repeating_call_counter = {}
        self.shutdown_timeout = None
        self.post_shutdown_lock = DeferredLock()
        self.stop_lock = DeferredLock()
        self.reannounce_lock = utility.TimedDeferredLock()
        self.stopped = False

        # Register a callback so self.shutdown_timeout is set when
        # "shutting_down" is set or modified.
        config.register_callback(
            "shutting_down", self.callback_shutting_down_changed)

class MKSPDR2000Wrapper(DeviceWrapper):
    @inlineCallbacks
    def connect(self, server, port):
        '''Connect to the MKS PDR2000'''
        print('Connecting to "%s" on port "%s"...' %(server.name, port))

        self.server = server
        self.ctx = server.context()
        self.port = port
        p = self.packet()
        p.open(port)
        # The following parameters were obtained from the MKS PDR2000 manual.
        p.baudrate(9600L)
        p.stopbits(1L)
        p.bytesize(8L)
        p.parity('N')
        p.timeout(0.1 * u.s)
        # Clear out the Rx buffer. This is necessary for some devices.
        yield p.send()
    
    def packet(self):
        '''Create a new packet in our private context'''
        return self.server.packet(context=self.ctx)

    def shutdown(self):
        '''Disconnect from teh serial port when we shut down.'''
        return self.packet().close().send()

    def rw_line(self, code):
        # Don't allow two concurrent read/write calls.
        
        self._lock = DeferredLock()

        return self._lock.run(partial(self._rw_line, code))

    @inlineCallbacks
    def _rw_line(self, code):
        '''Write data to the device.'''
        yield self.server.write_line(code, context=self.ctx)
        time.sleep(0.2)
        ans = yield self.server.read(context=self.ctx)
        returnValue(ans)
        
    @inlineCallbacks
    def getUnits(self):
        yield self.write_line('u')
        time.sleep(0.5)
        ans = yield self.read_line()
        returnValue(ans)
    def toFloat(self, val):
        try:
            if val == 'Off' or val == 'Low':
                return np.nan
            return float(val)
        except:
            return None

 def __init__(self, ident, signals):
     self.pause_lock = DeferredLock()
     self.pause_requests = []
     self.continue_requests = []
     self.already_called_continue = False
     self.status = 'Ready'
     self.percentage_complete = 0.0
     self.should_stop = False
     self.ident = ident
     self.signals = signals

 def add_scan_to_queue(self, scan, priority = 'Normal'):
     #increment counter
     scan_id = self.scan_ID_counter
     self.scan_ID_counter += 1
     #add to queue
     if priority == 'Normal':
         order = self.queue.put_last(1, (scan_id, scan,  1))
     elif priority == 'First in Queue':
         order = self.queue.put_first(1, (scan_id, scan, 1))
     elif priority == 'Pause All Others':
         order = self.queue.put_last(0, (scan_id, scan, 0))
     else: 
         raise Exception ("Unrecognized priority type")
     self.signals.on_queued_new_script((scan_id, scan.name, order))
     d = DeferredLock()
     d.acquire()
     self.running_locks[scan_id] = d
     self.launch_scripts()
     return scan_id

 def __init__(self, service, clock=reactor):
     """
     @param service: An object implementing the same whenConnected() API as
         the twisted.application.internet.ClientService class.
     @param clock: An object implementing IReactorTime.
     """
     self._service = service
     self._clock = clock
     self._channel = None
     self._channel_lock = DeferredLock()