The (remote) workhorse:
172316
@Override public final void compute2( ) {
    assert _key.home() : "Atomic on wrong node; SELF="+H2O.SELF+
      ", key_home="+_key.home_node()+", key_is_home="+_key.home()+", class="+getClass();
    Futures fs = new Futures(); // Must block on all invalidates eventually
    Value val1 = DKV.get(_key);
    while( true ) {
      // Run users' function.  This is supposed to read-only from val1 and
      // return new val2 to atomically install.
      Value val2 = atomic(val1);
      if( val2 == null ) break; // ABORT: they gave up
      assert val1 != val2;      // No returning the same Value
      // Attempt atomic update
      Value res = DKV.DputIfMatch(_key,val2,val1,fs);
      if( res == val1 ) {       // Success?
        onSuccess(val1);        // Call user's post-XTN function
        fs.blockForPending();   // Block for any pending invalidates on the atomic update
        break;
      }
      val1 = res;               // Otherwise try again with the current value
    }                           // and retry
    _key = null;                // No need for key no more, don't send it back
    tryComplete();              // Tell F/J this task is done
  }
425163
def process_pull
      factory = "::#{object_type}".constantize
      syncer = factory.synchronizer
      syncer.pull_object(self.object_remote_id)
      
      self.state = 'done'
      self.save
    end
1113128
def load_remote_data(self, callback_etat=print):
        
        callback_etat("Chargement des utilisateurs", 0, 1)
        self._load_users()
        self.base = self.BASE_CLASS.load_from_db(callback_etat=callback_etat)
1159279
def remote_addr
      if respond_to?(:remote_ip)
        __send__(:remote_ip)  # for Rails
      elsif respond_to?(:ip)
        __send__(:ip)         # for Rack
      else
        if env['HTTP_X_FORWARDED_FOR']
          env['HTTP_X_FORWARDED_FOR'].split(',').pop
        else
          env['REMOTE_ADDR']
        end
      end
    end
1048154
def _get_remote(self, cached=True):
        '''
        
        '''

        return self.m(
            'getting current remote',
            cmdd=dict(
                cmd='git remote show %s' % ('-n' if cached else ''),
                cwd=self.local
            ),
            verbose=False
        )
869343
private boolean remoteViewerActive() {
        if (remoteQueue == null) {
            return false;
        }
        
        if (!remoteQueue.isAlive()) {
            remoteQueue = null;
            return false;
        }
        
        return true;
    }
888139
def copy(self):
        """"""
        return Machine(
            self.width, self.height,
            self.chip_resources, self.chip_resource_exceptions,
            self.dead_chips, self.dead_links)
130145
def remote(self):
        
        from ambry.exc import NotFoundError

        ds = self.dataset

        if 'remote_name' not in ds.data:
            raise NotFoundError('Could not determine remote for partition: {}'.format(self.identity.fqname))

        return self._bundle.library.remote(ds.data['remote_name'])
625
def homegearCheckInit(self, remote):
        """"""
        rdict = self.remotes.get(remote)
        if not rdict:
            return False
        if rdict.get('type') != BACKEND_HOMEGEAR:
            return False
        try:
            interface_id = "%s-%s" % (self._interface_id, remote)
            return self.proxies[interface_id].clientServerInitialized(interface_id)
        except Exception as err:
            LOG.debug(
                "ServerThread.homegearCheckInit: Exception: %s" % str(err))
            return False
1356321
def remote_run(cmd, instance_name, detach=False, retries=1):
  """"""
  if detach:
    cmd = SCREEN.format(command=cmd)
  args = SSH.format(instance_name=instance_name).split()
  args.append(cmd)
  for i in range(retries + 1):
    try:
      if i > 0:
        tf.logging.info("Retry %d for %s", i, args)
      return sp.check_call(args)
    except sp.CalledProcessError as e:
      if i == retries:
        raise e
595401
def remote
      remote = []

      @branches.each do |branch|
        remote << branch if branch.remote?
      end

      BranchCollection.new(@repo, remote)
    end
1109873
function Connection (remote, options) {
  EventEmitter.call(this);

  if (remote[remote.length - 1] === '/') {
    remote = remote.substr(0, remote.length - 1);
  }

  this._remote = remote;
  this._retry = options.retry || 3;
  this._options = options || {};
  this._request_internal = createInternalConnection(options.mode);
}
1034401
function ensureConnected(remote, callback) {
  if (remote.getServer()) {
    callback(null, isConnected(remote));
  } else {
    callback(null, false);
  }
}
1172458
def write_to_remote(self, filepath_from, filepath_to, mtime_dt=None):
        """"""

        self.__log.debug("Writing L[%s] -> R[%s]." % (filepath_from, 
                                                      filepath_to))

        with open(filepath_from, 'rb') as file_from:
            with SftpFile(self, filepath_to, 'w') as sf_to:
                while 1:
                    part = file_from.read(MAX_MIRROR_WRITE_CHUNK_SIZE)
                    sf_to.write(part)

                    if len(part) < MAX_MIRROR_WRITE_CHUNK_SIZE:
                        break

        if mtime_dt is None:
            mtime_dt = datetime.now()

        self.utimes_dt(filepath_to, mtime_dt, mtime_dt)
1146249
def remote_transform(host, transform, input, entity_field, transform_parameter, raw_output, ssl,
                     base_path, soft_limit, hard_limit, verbose):
    """"""
    from canari.commands.remote_transform import remote_transform
    remote_transform(host, transform, input, entity_field, transform_parameter, raw_output, ssl,
                     base_path, soft_limit, hard_limit, verbose)
603497
def remote_port_uneq_store(self, remote_port):
        
        if remote_port != self.remote_port:
            self.remote_port = remote_port
            return True
        return False
1041425
def create_remote(self, name, url, **kwargs):
        """"""
        return Remote.create(self, name, url, **kwargs)