This method is a BinaryRedisPipeline command which dyno does not yet properly
support, therefore the interface is not yet implemented.
357471
public Response<List<byte[]>> hmget(final byte[] key, final byte[]... fields) {
		return new PipelineOperation<List<byte[]>>() {

			@Override
			Response<List<byte[]>> execute(Pipeline jedisPipeline) throws DynoException {
				long startTime = System.nanoTime() / 1000;
				try {
					return jedisPipeline.hmget(key, fields);
				} finally {
					long duration = System.nanoTime() / 1000 - startTime;
					opMonitor.recordSendLatency(OpName.HMGET.name(), duration, TimeUnit.MICROSECONDS);
				}
			}
		}.execute(key, OpName.HMGET);
	}
799800
private void configureClearText(SocketChannel ch) {
        final ChannelPipeline p = ch.pipeline();
        final HttpServerCodec sourceCodec = new HttpServerCodec();

        p.addLast(sourceCodec);
        p.addLast(new HttpServerUpgradeHandler(sourceCodec, upgradeCodecFactory));
        p.addLast(new SimpleChannelInboundHandler<HttpMessage>() {
            @Override
            protected void channelRead0(ChannelHandlerContext ctx, HttpMessage msg) throws Exception {
                // If this handler is hit then no upgrade has been attempted and the client is just talking HTTP.
                System.err.println("Directly talking: " + msg.protocolVersion() + " (no upgrade was attempted)");
                ChannelPipeline pipeline = ctx.pipeline();
                ChannelHandlerContext thisCtx = pipeline.context(this);
                pipeline.addAfter(thisCtx.name(), null, new HelloWorldHttp1Handler("Direct. No Upgrade Attempted."));
                pipeline.replace(this, null, new HttpObjectAggregator(maxHttpContentLength));
                ctx.fireChannelRead(ReferenceCountUtil.retain(msg));
            }
        });

        p.addLast(new UserEventLogger());
    }
1164937
def block_pipeline_command(func):
    

    def inner(*args, **kwargs):
        raise RedisClusterException(
            "ERROR: Calling pipelined function {0} is blocked when running redis in cluster mode...".format(
                func.__name__))

    return inner
1234454
public void processDI() {

    if (processDefinitions.isEmpty()) {
      return;
    }

    if (!bpmnModel.getLocationMap().isEmpty()) {

      // Verify if all referenced elements exist
      for (String bpmnReference : bpmnModel.getLocationMap().keySet()) {
        if (bpmnModel.getFlowElement(bpmnReference) == null) {
          // ACT-1625: don't warn when artifacts are referenced from DI
          if (bpmnModel.getArtifact(bpmnReference) == null) {
            // Check if it's a Pool or Lane, then DI is ok
            if (bpmnModel.getPool(bpmnReference) == null && bpmnModel.getLane(bpmnReference) == null) {
              LOGGER.warn("Invalid reference in diagram interchange definition: could not find " + bpmnReference);
            }
          }
        } else if (!(bpmnModel.getFlowElement(bpmnReference) instanceof FlowNode)) {
          LOGGER.warn("Invalid reference in diagram interchange definition: " + bpmnReference + " does not reference a flow node");
        }
      }
      
      for (String bpmnReference : bpmnModel.getFlowLocationMap().keySet()) {
        if (bpmnModel.getFlowElement(bpmnReference) == null) {
          // ACT-1625: don't warn when artifacts are referenced from DI
          if (bpmnModel.getArtifact(bpmnReference) == null) {
            LOGGER.warn("Invalid reference in diagram interchange definition: could not find " + bpmnReference);
          }
        } else if (!(bpmnModel.getFlowElement(bpmnReference) instanceof SequenceFlow)) {
          LOGGER.warn("Invalid reference in diagram interchange definition: " + bpmnReference + " does not reference a sequence flow");
        }
      }

      for (Process process : bpmnModel.getProcesses()) {
        if (!process.isExecutable()) {
          continue;
        }

        // Parse diagram interchange information
        ProcessDefinitionEntity processDefinition = getProcessDefinition(process.getId());
        if (processDefinition != null) {
          processDefinition.setGraphicalNotationDefined(true);
          
          for (String edgeId : bpmnModel.getFlowLocationMap().keySet()) {
            if (bpmnModel.getFlowElement(edgeId) != null) {
              createBPMNEdge(edgeId, bpmnModel.getFlowLocationGraphicInfo(edgeId));
            }
          }
        }
      }
    }
  }
1119014
DeviceData command_inout(String command, DeviceData argin) throws DevFailed {
        return tacoDevice.command_inout(this, command, argin);
    }
1005943
def run(self, **kwargs):
        
        if not (self.input and self.output and self.exe):
            raise RuntimeError("setup incomplete, can't run")
        self.logger.info("running MapReduce application")
        run_pipes(self.exe, self.input, self.output, **kwargs)
793803
public DeviceData command_inout_reply(int id, int timeout) throws DevFailed, AsynReplyNotArrived {
        return deviceProxyDAO.command_inout_reply(this, id, timeout);
    }
385640
def _build_command(self):
        

        command = [self._path]
        command.extend(["-N1"])  # use instance IDs for filenames
        command.extend(["-l", "dynamips_i{}_log.txt".format(self._id)])  # log file
        # Dynamips cannot listen for hypervisor commands and for console connections on
        # 2 different IP addresses.
        # See https://github.com/GNS3/dynamips/issues/62
        if self._console_host != "0.0.0.0" and self._console_host != "::":
            command.extend(["-H", "{}:{}".format(self._host, self._port)])
        else:
            command.extend(["-H", str(self._port)])
        return command
1346267
public void putDevicePipeProperty(String deviceName, DbPipe dbPipe) throws DevFailed {
        databaseDAO.putDevicePipeProperty(this, deviceName, dbPipe);
    }
198819
def pipe(self, command, timeout=None, cwd=None):
        
        if not timeout:
            timeout = self.timeout

        if not self.was_run:
            self.run(block=False, cwd=cwd)

        data = self.out

        if timeout:
            c = Command(command, timeout)
        else:
            c = Command(command)

        c.run(block=False, cwd=cwd)
        if data:
            c.send(data)
        c.block()
        return c
423539
static void waitForPipelineToFinish(PipelineResult result) {
    try {
      // Check to see if we are creating a template.
      // This should throw {@link UnsupportedOperationException} when creating a template.
      result.getState();

      State state = result.waitUntilFinish();
      LOG.info("Job finished with state: " + state.name());
      if (state != State.DONE) {
        System.exit(1);
      }
    } catch (UnsupportedOperationException e) {
      LOG.warn("Unable to wait for pipeline to finish.", e);
    }
  }
1119555
public String nonpipelineWrite(String key, DataGenerator dataGenerator) {
        String value = key + "__" + dataGenerator.getRandomValue() + "__" + key;
        String result = this.jedisClient.get().set(key, value);

        if (!"OK".equals(result)) {
            logger.error("SET_ERROR: GOT " + result + " for SET operation");
            throw new RuntimeException(String.format("DynoJedis: value %s for SET operation is NOT VALID", value, key));

        }

        return result;
    }
467556
def method_missing(method, *args, &block)
      if redis_operation?(method)
        dispatch(method, *args, &block)
      else
        super
      end
    end
1232288
def wait_for_binary_interface(self, **kwargs):
        
        if self.cluster.version() >= '1.2':
            self.watch_log_for("Starting listening for CQL clients", **kwargs)

        binary_itf = self.network_interfaces['binary']
        if not common.check_socket_listening(binary_itf, timeout=30):
            warnings.warn("Binary interface %s:%s is not listening after 30 seconds, node may have failed to start."
                          % (binary_itf[0], binary_itf[1]))
165973
public synchronized void startCommandPolling(final CommandImpl command) throws DevFailed {
        addCommandPolling(command);
        LOGGER.debug("starting command {} for polling on device {}", command.getName(), deviceName);
        if (command.getPollingPeriod() != 0) {
            commandCacheMap.get(command).startRefresh(POLLING_POOL);
        }
    }
76573
function setupPipeline() {
      var deps = bundler.pipeline.get('deps');
      deps.push(getCache(deps._streams[0].cache));
    }
241669
public void pushPipeEvent(final String pipeName, final PipeValue blob) throws DevFailed {
        // set attribute value
        final PipeImpl pipe = DeviceImpl.getPipe(pipeName, device.getPipeList());
        try {
            pipe.updateValue(blob);
            // push the event
            EventManager.getInstance().pushPipeEvent(name, pipeName, blob);
        } catch (final DevFailed e) {
            EventManager.getInstance().pushPipeEvent(name, pipeName, e);
        }
    }