code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
public void record(ByteBuffer block, int offset) {
if (this.data == null) {
// TODO: remove cast to int when large ByteBuffer support is
// implemented in Java.
this.data = ByteBuffer.allocate((int) this.length);
}
int pos = block.position();
this.data.position(offset);
this.data.put(block);
block.position(pos);
} | java |
public int compareTo(Piece other) {
// return true for the same pieces, otherwise sort by time seen, then by index;
if (this.equals(other)) {
return 0;
} else if (this.seen == other.seen) {
return new Integer(this.index).compareTo(other.index);
} else if (this.seen < other.seen) {
return -1;
} else {
return 1;
}
} | java |
public void addPeer(TrackedPeer peer) {
this.peers.put(new PeerUID(peer.getAddress(), this.getHexInfoHash()), peer);
} | java |
public List<Peer> getSomePeers(Peer peer) {
List<Peer> peers = new LinkedList<Peer>();
// Extract answerPeers random peers
List<TrackedPeer> candidates = new LinkedList<TrackedPeer>(this.peers.values());
Collections.shuffle(candidates);
int count = 0;
for (TrackedPeer candidate : candidates) {
// Don't include the requesting peer in the answer.
if (peer != null && peer.looksLike(candidate)) {
continue;
}
// Only serve at most ANSWER_NUM_PEERS peers
if (count++ > this.answerPeers) {
break;
}
peers.add(candidate);
}
return peers;
} | java |
public static TrackedTorrent load(File torrent) throws IOException {
TorrentMetadata torrentMetadata = new TorrentParser().parseFromFile(torrent);
return new TrackedTorrent(torrentMetadata.getInfoHash());
} | java |
public TorrentManager addTorrent(String dotTorrentFilePath, String downloadDirPath) throws IOException {
return addTorrent(dotTorrentFilePath, downloadDirPath, FairPieceStorageFactory.INSTANCE);
} | java |
public TorrentManager addTorrent(String dotTorrentFilePath, String downloadDirPath, List<TorrentListener> listeners) throws IOException {
return addTorrent(dotTorrentFilePath, downloadDirPath, FairPieceStorageFactory.INSTANCE, listeners);
} | java |
public TorrentManager addTorrent(TorrentMetadataProvider metadataProvider, PieceStorage pieceStorage) throws IOException {
return addTorrent(metadataProvider, pieceStorage, Collections.<TorrentListener>emptyList());
} | java |
public TorrentManager addTorrent(TorrentMetadataProvider metadataProvider,
PieceStorage pieceStorage,
List<TorrentListener> listeners) throws IOException {
TorrentMetadata torrentMetadata = metadataProvider.getTorrentMetadata();
EventDispatcher eventDispatcher = new EventDispatcher();
for (TorrentListener listener : listeners) {
eventDispatcher.addListener(listener);
}
final LoadedTorrentImpl loadedTorrent = new LoadedTorrentImpl(
new TorrentStatistic(),
metadataProvider,
torrentMetadata,
pieceStorage,
eventDispatcher);
if (pieceStorage.isFinished()) {
loadedTorrent.getTorrentStatistic().setLeft(0);
} else {
long left = calculateLeft(pieceStorage, torrentMetadata);
loadedTorrent.getTorrentStatistic().setLeft(left);
}
eventDispatcher.multicaster().validationComplete(pieceStorage.getAvailablePieces().cardinality(), torrentMetadata.getPiecesCount());
this.torrentsStorage.addTorrent(loadedTorrent.getTorrentHash().getHexInfoHash(), loadedTorrent);
forceAnnounceAndLogError(loadedTorrent, pieceStorage.isFinished() ? COMPLETED : STARTED);
logger.debug(String.format("Added torrent %s (%s)", loadedTorrent, loadedTorrent.getTorrentHash().getHexInfoHash()));
return new TorrentManagerImpl(eventDispatcher, loadedTorrent.getTorrentHash());
} | java |
public void removeTorrent(String torrentHash) {
logger.debug("Stopping seeding " + torrentHash);
final Pair<SharedTorrent, LoadedTorrent> torrents = torrentsStorage.remove(torrentHash);
SharedTorrent torrent = torrents.first();
if (torrent != null) {
torrent.setClientState(ClientState.DONE);
torrent.closeFully();
}
List<SharingPeer> peers = getPeersForTorrent(torrentHash);
for (SharingPeer peer : peers) {
peer.unbind(true);
}
sendStopEvent(torrents.second(), torrentHash);
} | java |
public boolean isSeed(String hexInfoHash) {
SharedTorrent t = this.torrentsStorage.getTorrent(hexInfoHash);
return t != null && t.isComplete();
} | java |
@Override
public void handleAnnounceResponse(int interval, int complete, int incomplete, String hexInfoHash) {
final SharedTorrent sharedTorrent = this.torrentsStorage.getTorrent(hexInfoHash);
if (sharedTorrent != null) {
sharedTorrent.setSeedersCount(complete);
sharedTorrent.setLastAnnounceTime(System.currentTimeMillis());
}
setAnnounceInterval(interval);
} | java |
@Override
public void handleDiscoveredPeers(List<Peer> peers, String hexInfoHash) {
if (peers.size() == 0) return;
SharedTorrent torrent = torrentsStorage.getTorrent(hexInfoHash);
if (torrent != null && torrent.isFinished()) return;
final LoadedTorrent announceableTorrent = torrentsStorage.getLoadedTorrent(hexInfoHash);
if (announceableTorrent == null) {
logger.info("announceable torrent {} is not found in storage. Maybe it was removed", hexInfoHash);
return;
}
if (announceableTorrent.getPieceStorage().isFinished()) return;
logger.debug("Got {} peer(s) ({}) for {} in tracker response", new Object[]{peers.size(),
Arrays.toString(peers.toArray()), hexInfoHash});
Map<PeerUID, Peer> uniquePeers = new HashMap<PeerUID, Peer>();
for (Peer peer : peers) {
final PeerUID peerUID = new PeerUID(peer.getAddress(), hexInfoHash);
if (uniquePeers.containsKey(peerUID)) continue;
uniquePeers.put(peerUID, peer);
}
for (Map.Entry<PeerUID, Peer> e : uniquePeers.entrySet()) {
PeerUID peerUID = e.getKey();
Peer peer = e.getValue();
boolean alreadyConnectedToThisPeer = peersStorage.getSharingPeer(peerUID) != null;
if (alreadyConnectedToThisPeer) {
logger.debug("skipping peer {}, because we already connected to this peer", peer);
continue;
}
ConnectionListener connectionListener = new OutgoingConnectionListener(
this,
announceableTorrent.getTorrentHash(),
peer.getIp(),
peer.getPort());
logger.debug("trying to connect to the peer {}", peer);
boolean connectTaskAdded = this.myConnectionManager.offerConnect(
new ConnectTask(peer.getIp(),
peer.getPort(),
connectionListener,
new SystemTimeService().now(),
Constants.DEFAULT_CONNECTION_TIMEOUT_MILLIS), 1, TimeUnit.SECONDS);
if (!connectTaskAdded) {
logger.info("can not connect to peer {}. Unable to add connect task to connection manager", peer);
}
}
} | java |
public static String byteArrayToHexString(byte[] bytes) {
char[] hexChars = new char[bytes.length * 2];
for (int j = 0; j < bytes.length; j++) {
int v = bytes[j] & 0xFF;
hexChars[j * 2] = HEX_SYMBOLS[v >>> 4];
hexChars[j * 2 + 1] = HEX_SYMBOLS[v & 0x0F];
}
return new String(hexChars);
} | java |
@Bean
@ConditionalOnMissingBean(ZookeeperHealthIndicator.class)
@ConditionalOnBean(CuratorFramework.class)
@ConditionalOnEnabledHealthIndicator("zookeeper")
public ZookeeperHealthIndicator zookeeperHealthIndicator(CuratorFramework curator) {
return new ZookeeperHealthIndicator(curator);
} | java |
private void createProxies() {
source = createProxy(sourceType);
destination = createProxy(destinationType);
for (VisitedMapping mapping : visitedMappings) {
createAccessorProxies(source, mapping.sourceAccessors);
createAccessorProxies(destination, mapping.destinationAccessors);
}
} | java |
private void validateRecordedMapping() {
if (currentMapping.destinationMutators == null || currentMapping.destinationMutators.isEmpty())
errors.missingDestination();
// If mapping a field without a source
else if (options.skipType == 0
&& (currentMapping.sourceAccessors == null || currentMapping.sourceAccessors.isEmpty())
&& currentMapping.destinationMutators.get(currentMapping.destinationMutators.size() - 1)
.getPropertyType()
.equals(PropertyType.FIELD) && options.converter == null && !options.mapFromSource
&& sourceConstant == null)
errors.missingSource();
else if (options.skipType == 2 && options.condition != null)
errors.conditionalSkipWithoutSource();
} | java |
@SuppressWarnings("unchecked")
static <T> TypeInfoImpl<T> typeInfoFor(Class<T> sourceType, InheritingConfiguration configuration) {
TypeInfoKey pair = new TypeInfoKey(sourceType, configuration);
TypeInfoImpl<T> typeInfo = (TypeInfoImpl<T>) cache.get(pair);
if (typeInfo == null) {
synchronized (cache) {
typeInfo = (TypeInfoImpl<T>) cache.get(pair);
if (typeInfo == null) {
typeInfo = new TypeInfoImpl<T>(null, sourceType, configuration);
cache.put(pair, typeInfo);
}
}
}
return typeInfo;
} | java |
public static boolean mightContainsProperties(Class<?> type) {
return type != Object.class
&& type != String.class
&& type != Date.class
&& type != Calendar.class
&& !Primitives.isPrimitive(type)
&& !Iterables.isIterable(type)
&& !Types.isGroovyType(type);
} | java |
private void mergeMappings(TypeMap<?, ?> destinationMap) {
for (Mapping mapping : destinationMap.getMappings()) {
InternalMapping internalMapping = (InternalMapping) mapping;
mergedMappings.add(internalMapping.createMergedCopy(
propertyNameInfo.getSourceProperties(), propertyNameInfo.getDestinationProperties()));
}
} | java |
private boolean isConvertable(Mapping mapping) {
if (mapping == null || mapping.getProvider() != null || !(mapping instanceof PropertyMapping))
return false;
PropertyMapping propertyMapping = (PropertyMapping) mapping;
boolean hasSupportConverter = converterStore.getFirstSupported(
propertyMapping.getLastSourceProperty().getType(),
mapping.getLastDestinationProperty().getType()) != null;
boolean hasSupportTypeMap = typeMapStore.get(
propertyMapping.getLastSourceProperty().getType(),
mapping.getLastDestinationProperty().getType(),
null) != null;
return hasSupportConverter || hasSupportTypeMap;
} | java |
static void mapAutomatically() {
Order order = createOrder();
ModelMapper modelMapper = new ModelMapper();
OrderDTO orderDTO = modelMapper.map(order, OrderDTO.class);
assertOrdersEqual(order, orderDTO);
} | java |
static void mapExplicitly() {
Order order = createOrder();
ModelMapper modelMapper = new ModelMapper();
modelMapper.addMappings(new PropertyMap<Order, OrderDTO>() {
@Override
protected void configure() {
map().setBillingStreet(source.getBillingAddress().getStreet());
map(source.billingAddress.getCity(), destination.billingCity);
}
});
OrderDTO orderDTO = modelMapper.map(order, OrderDTO.class);
assertOrdersEqual(order, orderDTO);
} | java |
public static <T> Collection<T> createCollection(MappingContext<?, Collection<T>> context) {
if (context.getDestinationType().isInterface())
if (SortedSet.class.isAssignableFrom(context.getDestinationType()))
return new TreeSet<T>();
else if (Set.class.isAssignableFrom(context.getDestinationType()))
return new HashSet<T>();
else
return new ArrayList<T>();
return context.getMappingEngine().createDestination(context);
} | java |
public static String format(String heading, Collection<ErrorMessage> errorMessages) {
@SuppressWarnings("resource")
Formatter fmt = new Formatter().format(heading).format(":%n%n");
int index = 1;
boolean displayCauses = getOnlyCause(errorMessages) == null;
for (ErrorMessage errorMessage : errorMessages) {
fmt.format("%s) %s%n", index++, errorMessage.getMessage());
Throwable cause = errorMessage.getCause();
if (displayCauses && cause != null) {
StringWriter writer = new StringWriter();
cause.printStackTrace(new PrintWriter(writer));
fmt.format("Caused by: %s", writer.getBuffer());
}
fmt.format("%n");
}
if (errorMessages.size() == 1)
fmt.format("1 error");
else
fmt.format("%s errors", errorMessages.size());
return fmt.toString();
} | java |
public Map<String, Accessor> getAccessors() {
if (accessors == null)
synchronized (this) {
if (accessors == null)
accessors = PropertyInfoSetResolver.resolveAccessors(source, type, configuration);
}
return accessors;
} | java |
public Map<String, Mutator> getMutators() {
if (mutators == null)
synchronized (this) {
if (mutators == null)
mutators = PropertyInfoSetResolver.resolveMutators(type, configuration);
}
return mutators;
} | java |
static synchronized Accessor accessorFor(Class<?> type, Method method,
Configuration configuration, String name) {
PropertyInfoKey key = new PropertyInfoKey(type, name, configuration);
Accessor accessor = ACCESSOR_CACHE.get(key);
if (accessor == null) {
accessor = new MethodAccessor(type, method, name);
ACCESSOR_CACHE.put(key, accessor);
}
return accessor;
} | java |
static synchronized FieldPropertyInfo fieldPropertyFor(Class<?> type, Field field,
Configuration configuration, String name) {
PropertyInfoKey key = new PropertyInfoKey(type, name, configuration);
FieldPropertyInfo fieldPropertyInfo = FIELD_CACHE.get(key);
if (fieldPropertyInfo == null) {
fieldPropertyInfo = new FieldPropertyInfo(type, field, name);
FIELD_CACHE.put(key, fieldPropertyInfo);
}
return fieldPropertyInfo;
} | java |
static synchronized Mutator mutatorFor(Class<?> type, Method method, Configuration configuration,
String name) {
PropertyInfoKey key = new PropertyInfoKey(type, name, configuration);
Mutator mutator = MUTATOR_CACHE.get(key);
if (mutator == null) {
mutator = new MethodMutator(type, method, name);
MUTATOR_CACHE.put(key, mutator);
}
return mutator;
} | java |
@SuppressWarnings("unchecked")
public static int getLength(Object iterable) {
Assert.state(isIterable(iterable.getClass()));
return iterable.getClass().isArray() ? Array.getLength(iterable) : ((Collection<Object>) iterable).size();
} | java |
@SuppressWarnings("unchecked")
public static Iterator<Object> iterator(Object iterable) {
Assert.state(isIterable(iterable.getClass()));
return iterable.getClass().isArray() ? new ArrayIterator(iterable)
: ((Iterable<Object>) iterable).iterator();
} | java |
@SuppressWarnings("unchecked")
public static Object getElement(Object iterable, int index) {
if (iterable.getClass().isArray())
return getElementFromArrary(iterable, index);
if (iterable instanceof Collection)
return getElementFromCollection((Collection<Object>) iterable, index);
return null;
} | java |
public static Object getElementFromArrary(Object array, int index) {
try {
return Array.get(array, index);
} catch (ArrayIndexOutOfBoundsException e) {
return null;
}
} | java |
public static Object getElementFromCollection(Collection<Object> collection, int index) {
if (collection.size() < index + 1)
return null;
if (collection instanceof List)
return ((List<Object>) collection).get(index);
Iterator<Object> iterator = collection.iterator();
for (int i = 0; i < index; i++) {
iterator.next();
}
return iterator.next();
} | java |
public synchronized @Nonnull String version() throws IOException {
if (this.version == null) {
Process p = runFunc.run(ImmutableList.of(path, "-version"));
try {
BufferedReader r = wrapInReader(p);
this.version = r.readLine();
CharStreams.copy(r, CharStreams.nullWriter()); // Throw away rest of the output
throwOnError(p);
} finally {
p.destroy();
}
}
return version;
} | java |
public List<String> path(List<String> args) throws IOException {
return ImmutableList.<String>builder().add(path).addAll(args).build();
} | java |
public static URI checkValidStream(URI uri) throws IllegalArgumentException {
String scheme = checkNotNull(uri).getScheme();
scheme = checkNotNull(scheme, "URI is missing a scheme").toLowerCase();
if (rtps.contains(scheme)) {
return uri;
}
if (udpTcp.contains(scheme)) {
if (uri.getPort() == -1) {
throw new IllegalArgumentException("must set port when using udp or tcp scheme");
}
return uri;
}
throw new IllegalArgumentException("not a valid output URL, must use rtp/tcp/udp scheme");
} | java |
public void read(NutDataInputStream in, long startcode) throws IOException {
this.startcode = startcode;
forwardPtr = in.readVarLong();
if (forwardPtr > 4096) {
long expected = in.getCRC();
checksum = in.readInt();
if (checksum != expected) {
// TODO This code path has never been tested.
throw new IOException(
String.format("invalid header checksum %X want %X", expected, checksum));
}
}
in.resetCRC();
end = in.offset() + forwardPtr - 4; // 4 bytes for footer CRC
} | java |
@CheckReturnValue
@Override
public EncodingOptions buildOptions() {
// TODO When/if modelmapper supports @ConstructorProperties, we map this
// object, instead of doing new XXX(...)
// https://github.com/jhalterman/modelmapper/issues/44
return new EncodingOptions(
new MainEncodingOptions(format, startOffset, duration),
new AudioEncodingOptions(
audio_enabled,
audio_codec,
audio_channels,
audio_sample_rate,
audio_sample_format,
audio_bit_rate,
audio_quality),
new VideoEncodingOptions(
video_enabled,
video_codec,
video_frame_rate,
video_width,
video_height,
video_bit_rate,
video_frames,
video_filter,
video_preset));
} | java |
protected void readFileId() throws IOException {
byte[] b = new byte[HEADER.length];
in.readFully(b);
if (!Arrays.equals(b, HEADER)) {
throw new IOException(
"file_id_string does not match. got: " + new String(b, Charsets.ISO_8859_1));
}
} | java |
protected long readReservedHeaders() throws IOException {
long startcode = in.readStartCode();
while (Startcode.isPossibleStartcode(startcode) && isKnownStartcode(startcode)) {
new Packet().read(in, startcode); // Discard unknown packet
startcode = in.readStartCode();
}
return startcode;
} | java |
public void read() throws IOException {
readFileId();
in.resetCRC();
long startcode = in.readStartCode();
while (true) {
// Start parsing main and stream information
header = new MainHeaderPacket();
if (!Startcode.MAIN.equalsCode(startcode)) {
throw new IOException(String.format("expected main header found: 0x%X", startcode));
}
header.read(in, startcode);
startcode = readReservedHeaders();
streams.clear();
for (int i = 0; i < header.streamCount; i++) {
if (!Startcode.STREAM.equalsCode(startcode)) {
throw new IOException(String.format("expected stream header found: 0x%X", startcode));
}
StreamHeaderPacket streamHeader = new StreamHeaderPacket();
streamHeader.read(in, startcode);
Stream stream = new Stream(header, streamHeader);
streams.add(stream);
listener.stream(stream);
startcode = readReservedHeaders();
}
while (Startcode.INFO.equalsCode(startcode)) {
new Packet().read(in, startcode); // Discard for the moment
startcode = readReservedHeaders();
}
if (Startcode.INDEX.equalsCode(startcode)) {
new Packet().read(in, startcode); // Discard for the moment
startcode = in.readStartCode();
}
// Now main frame parsing loop
while (!Startcode.MAIN.equalsCode(startcode)) {
if (Startcode.SYNCPOINT.equalsCode(startcode)) {
new Packet().read(in, startcode); // Discard for the moment
startcode = in.readStartCode();
}
if (Startcode.isPossibleStartcode(startcode)) {
throw new IOException("expected framecode, found " + Startcode.toString(startcode));
}
Frame f = new Frame();
f.read(this, in, (int) startcode);
listener.frame(f);
try {
startcode = readReservedHeaders();
} catch (java.io.EOFException e) {
return;
}
}
}
} | java |
public T setVideoFrameRate(Fraction frame_rate) {
this.video_enabled = true;
this.video_frame_rate = checkNotNull(frame_rate);
return getThis();
} | java |
public T addMetaTag(String key, String value) {
checkValidKey(key);
checkNotEmpty(value, "value must not be empty");
meta_tags.add("-metadata");
meta_tags.add(key + "=" + value);
return getThis();
} | java |
public T setAudioChannels(int channels) {
checkArgument(channels > 0, "channels must be positive");
this.audio_enabled = true;
this.audio_channels = channels;
return getThis();
} | java |
public T setAudioSampleRate(int sample_rate) {
checkArgument(sample_rate > 0, "sample rate must be positive");
this.audio_enabled = true;
this.audio_sample_rate = sample_rate;
return getThis();
} | java |
public T setStartOffset(long offset, TimeUnit units) {
checkNotNull(units);
this.startOffset = units.toMillis(offset);
return getThis();
} | java |
public T setDuration(long duration, TimeUnit units) {
checkNotNull(units);
this.duration = units.toMillis(duration);
return getThis();
} | java |
public T setAudioPreset(String preset) {
this.audio_enabled = true;
this.audio_preset = checkNotEmpty(preset, "audio preset must not be empty");
return getThis();
} | java |
public T setSubtitlePreset(String preset) {
this.subtitle_enabled = true;
this.subtitle_preset = checkNotEmpty(preset, "subtitle preset must not be empty");
return getThis();
} | java |
public int readVarInt() throws IOException {
boolean more;
int result = 0;
do {
int b = in.readUnsignedByte();
more = (b & 0x80) == 0x80;
result = 128 * result + (b & 0x7F);
// TODO Check for int overflow
} while (more);
return result;
} | java |
public long readVarLong() throws IOException {
boolean more;
long result = 0;
do {
int b = in.readUnsignedByte();
more = (b & 0x80) == 0x80;
result = 128 * result + (b & 0x7F);
// TODO Check for long overflow
} while (more);
return result;
} | java |
public byte[] readVarArray() throws IOException {
int len = (int) readVarLong();
byte[] result = new byte[len];
in.read(result);
return result;
} | java |
public long readStartCode() throws IOException {
byte frameCode = in.readByte();
if (frameCode != 'N') {
return (long) (frameCode & 0xff);
}
// Otherwise read the remaining 64bit startCode
byte[] buffer = new byte[8];
buffer[0] = frameCode;
readFully(buffer, 1, 7);
return (((long) buffer[0] << 56)
+ ((long) (buffer[1] & 255) << 48)
+ ((long) (buffer[2] & 255) << 40)
+ ((long) (buffer[3] & 255) << 32)
+ ((long) (buffer[4] & 255) << 24)
+ ((buffer[5] & 255) << 16)
+ ((buffer[6] & 255) << 8)
+ ((buffer[7] & 255) << 0));
} | java |
public static StreamSpecifier stream(StreamSpecifierType type, int index) {
checkNotNull(type);
return new StreamSpecifier(type.toString() + ":" + index);
} | java |
public static StreamSpecifier tag(String key, String value) {
checkValidKey(key);
checkNotNull(value);
return new StreamSpecifier("m:" + key + ":" + value);
} | java |
protected boolean parseLine(String line) {
line = checkNotNull(line).trim();
if (line.isEmpty()) {
return false; // Skip empty lines
}
final String[] args = line.split("=", 2);
if (args.length != 2) {
// invalid argument, so skip
return false;
}
final String key = checkNotNull(args[0]);
final String value = checkNotNull(args[1]);
switch (key) {
case "frame":
frame = Long.parseLong(value);
return false;
case "fps":
fps = Fraction.getFraction(value);
return false;
case "bitrate":
if (value.equals("N/A")) {
bitrate = -1;
} else {
bitrate = FFmpegUtils.parseBitrate(value);
}
return false;
case "total_size":
if (value.equals("N/A")) {
total_size = -1;
} else {
total_size = Long.parseLong(value);
}
return false;
case "out_time_ms":
// This is a duplicate of the "out_time" field, but expressed as a int instead of string.
// Note this value is in microseconds, not milliseconds, and is based on AV_TIME_BASE which
// could change.
// out_time_ns = Long.parseLong(value) * 1000;
return false;
case "out_time":
out_time_ns = fromTimecode(value);
return false;
case "dup_frames":
dup_frames = Long.parseLong(value);
return false;
case "drop_frames":
drop_frames = Long.parseLong(value);
return false;
case "speed":
if (value.equals("N/A")) {
speed = -1;
} else {
speed = Float.parseFloat(value.replace("x", ""));
}
return false;
case "progress":
// TODO After "end" stream is closed
status = Status.of(value);
return true; // The status field is always last in the record
default:
if (key.startsWith("stream_")) {
// TODO handle stream_0_0_q=0.0:
// stream_%d_%d_q= file_index, index, quality
// stream_%d_%d_psnr_%c=%2.2f, file_index, index, type{Y, U, V}, quality // Enable with
// AV_CODEC_FLAG_PSNR
// stream_%d_%d_psnr_all
} else {
LOG.warn("skipping unhandled key: {} = {}", key, value);
}
return false; // Either way, not supported
}
} | java |
@CheckReturnValue
static URI createUri(String scheme, InetAddress address, int port) throws URISyntaxException {
checkNotNull(address);
return new URI(
scheme,
null /* userInfo */,
InetAddresses.toUriString(address),
port,
null /* path */,
null /* query */,
null /* fragment */);
} | java |
@Override
public synchronized void start() {
if (thread != null) {
throw new IllegalThreadStateException("Parser already started");
}
String name = getThreadName() + "(" + getUri().toString() + ")";
CountDownLatch startSignal = new CountDownLatch(1);
Runnable runnable = getRunnable(startSignal);
thread = new Thread(runnable, name);
thread.start();
// Block until the thread has started
try {
startSignal.await();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
} | java |
public static long parseBitrate(String bitrate) {
if ("N/A".equals(bitrate)) {
return -1;
}
Matcher m = BITRATE_REGEX.matcher(bitrate);
if (!m.find()) {
throw new IllegalArgumentException("Invalid bitrate '" + bitrate + "'");
}
return (long) (Float.parseFloat(m.group(1)) * 1000);
} | java |
public static int waitForWithTimeout(final Process p, long timeout, TimeUnit unit)
throws TimeoutException {
ProcessThread t = new ProcessThread(p);
t.start();
try {
unit.timedJoin(t, timeout);
} catch (InterruptedException e) {
t.interrupt();
Thread.currentThread().interrupt();
}
if (!t.hasFinished()) {
throw new TimeoutException("Process did not finish within timeout");
}
return t.exitValue();
} | java |
public T get()
throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException,
InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException,
InternalException {
if (ex == null) {
return type;
}
if (ex instanceof InvalidBucketNameException) {
throw (InvalidBucketNameException) ex;
} else if (ex instanceof NoSuchAlgorithmException) {
throw (NoSuchAlgorithmException) ex;
} else if (ex instanceof InsufficientDataException) {
throw (InsufficientDataException) ex;
} else if (ex instanceof IOException) {
throw (IOException) ex;
} else if (ex instanceof InvalidKeyException) {
throw (InvalidKeyException) ex;
} else if (ex instanceof NoResponseException) {
throw (NoResponseException) ex;
} else if (ex instanceof XmlPullParserException) {
throw (XmlPullParserException) ex;
} else if (ex instanceof ErrorResponseException) {
throw (ErrorResponseException) ex;
} else {
throw (InternalException) ex;
}
} | java |
private boolean isValidEndpoint(String endpoint) {
if (InetAddressValidator.getInstance().isValid(endpoint)) {
return true;
}
// endpoint may be a hostname
// refer https://en.wikipedia.org/wiki/Hostname#Restrictions_on_valid_host_names
// why checks are done like below
if (endpoint.length() < 1 || endpoint.length() > 253) {
return false;
}
for (String label : endpoint.split("\\.")) {
if (label.length() < 1 || label.length() > 63) {
return false;
}
if (!(label.matches("^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$"))) {
return false;
}
}
return true;
} | java |
private void checkBucketName(String name) throws InvalidBucketNameException {
if (name == null) {
throw new InvalidBucketNameException(NULL_STRING, "null bucket name");
}
// Bucket names cannot be no less than 3 and no more than 63 characters long.
if (name.length() < 3 || name.length() > 63) {
String msg = "bucket name must be at least 3 and no more than 63 characters long";
throw new InvalidBucketNameException(name, msg);
}
// Successive periods in bucket names are not allowed.
if (name.matches("\\.\\.")) {
String msg = "bucket name cannot contain successive periods. For more information refer "
+ "http://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html";
throw new InvalidBucketNameException(name, msg);
}
// Bucket names should be dns compatible.
if (!name.matches("^[a-z0-9][a-z0-9\\.\\-]+[a-z0-9]$")) {
String msg = "bucket name does not follow Amazon S3 standards. For more information refer "
+ "http://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html";
throw new InvalidBucketNameException(name, msg);
}
} | java |
public void setTimeout(long connectTimeout, long writeTimeout, long readTimeout) {
this.httpClient = this.httpClient.newBuilder()
.connectTimeout(connectTimeout, TimeUnit.MILLISECONDS)
.writeTimeout(writeTimeout, TimeUnit.MILLISECONDS)
.readTimeout(readTimeout, TimeUnit.MILLISECONDS)
.build();
} | java |
@SuppressFBWarnings(value = "SIC", justification = "Should not be used in production anyways.")
public void ignoreCertCheck() throws NoSuchAlgorithmException, KeyManagementException {
final TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
@Override
public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
}
@Override
public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
}
@Override
public X509Certificate[] getAcceptedIssuers() {
return new X509Certificate[]{};
}
}
};
final SSLContext sslContext = SSLContext.getInstance("SSL");
sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
final SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();
this.httpClient = this.httpClient.newBuilder()
.sslSocketFactory(sslSocketFactory, (X509TrustManager)trustAllCerts[0])
.hostnameVerifier(new HostnameVerifier() {
@Override
public boolean verify(String hostname, SSLSession session) {
return true;
}
})
.build();
} | java |
private boolean shouldOmitPortInHostHeader(HttpUrl url) {
return (url.scheme().equals("http") && url.port() == 80)
|| (url.scheme().equals("https") && url.port() == 443);
} | java |
private HttpResponse execute(Method method, String region, String bucketName, String objectName,
Map<String,String> headerMap, Map<String,String> queryParamMap,
Object body, int length)
throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException,
InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException,
InternalException {
if (headerMap != null) {
headerMap = normalizeHeaders(headerMap);
}
Multimap<String, String> queryParamMultiMap = null;
if (queryParamMap != null) {
queryParamMultiMap = Multimaps.forMap(queryParamMap);
}
Multimap<String, String> headerMultiMap = null;
if (headerMap != null) {
headerMultiMap = Multimaps.forMap(headerMap);
}
return executeReq(method, region, bucketName, objectName, headerMultiMap, queryParamMultiMap, body, length);
} | java |
private void updateRegionCache(String bucketName)
throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException,
InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException,
InternalException {
if (bucketName != null && this.accessKey != null && this.secretKey != null
&& !BucketRegionCache.INSTANCE.exists(bucketName)) {
Map<String,String> queryParamMap = new HashMap<>();
queryParamMap.put("location", null);
HttpResponse response = execute(Method.GET, US_EAST_1, bucketName, "/",
null, queryParamMap, null, 0);
// existing XmlEntity does not work, so fallback to regular parsing.
XmlPullParser xpp = xmlPullParserFactory.newPullParser();
String location = null;
try (ResponseBody body = response.body()) {
xpp.setInput(body.charStream());
while (xpp.getEventType() != XmlPullParser.END_DOCUMENT) {
if (xpp.getEventType() == XmlPullParser.START_TAG && "LocationConstraint".equals(xpp.getName())) {
xpp.next();
location = getText(xpp);
break;
}
xpp.next();
}
}
String region;
if (location == null) {
region = US_EAST_1;
} else {
// eu-west-1 can be sometimes 'EU'.
if ("EU".equals(location)) {
region = "eu-west-1";
} else {
region = location;
}
}
// Add the new location.
BucketRegionCache.INSTANCE.set(bucketName, region);
}
} | java |
private String getRegion(String bucketName) throws InvalidBucketNameException, NoSuchAlgorithmException,
InsufficientDataException, IOException, InvalidKeyException, NoResponseException, XmlPullParserException,
ErrorResponseException, InternalException {
String region;
if (this.region == null || "".equals(this.region)) {
updateRegionCache(bucketName);
region = BucketRegionCache.INSTANCE.region(bucketName);
} else {
region = this.region;
}
return region;
} | java |
private String getText(XmlPullParser xpp) throws XmlPullParserException {
if (xpp.getEventType() == XmlPullParser.TEXT) {
return xpp.getText();
}
return null;
} | java |
private HttpResponse executeGet(String bucketName, String objectName, Map<String,String> headerMap,
Map<String,String> queryParamMap)
throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException,
InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException,
InternalException {
return execute(Method.GET, getRegion(bucketName), bucketName, objectName, headerMap, queryParamMap, null, 0);
} | java |
private HttpResponse executeHead(String bucketName, String objectName, Map<String,String> headerMap)
throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException,
InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException,
InternalException {
HttpResponse response = execute(Method.HEAD, getRegion(bucketName), bucketName, objectName, headerMap,
null, null, 0);
response.body().close();
return response;
} | java |
private HttpResponse executeDelete(String bucketName, String objectName, Map<String,String> queryParamMap)
throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException,
InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException,
InternalException {
HttpResponse response = execute(Method.DELETE, getRegion(bucketName), bucketName, objectName, null,
queryParamMap, null, 0);
response.body().close();
return response;
} | java |
private HttpResponse executePost(String bucketName, String objectName, Map<String,String> headerMap,
Map<String,String> queryParamMap, Object data)
throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException,
InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException,
InternalException {
return execute(Method.POST, getRegion(bucketName), bucketName, objectName, headerMap, queryParamMap, data, 0);
} | java |
public String getObjectUrl(String bucketName, String objectName)
throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException,
InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException,
InternalException {
Request request = createRequest(Method.GET, bucketName, objectName, getRegion(bucketName),
null, null, null, null, 0);
HttpUrl url = request.url();
return url.toString();
} | java |
public void copyObject(String bucketName, String objectName, String destBucketName)
throws InvalidKeyException, InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException,
NoResponseException, ErrorResponseException, InternalException, IOException, XmlPullParserException,
InvalidArgumentException {
copyObject(bucketName, objectName, destBucketName, null, null, null);
} | java |
public String getPresignedObjectUrl(Method method, String bucketName, String objectName, Integer expires,
Map<String, String> reqParams)
throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException,
InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException,
InternalException, InvalidExpiresRangeException {
// Validate input.
if (expires < 1 || expires > DEFAULT_EXPIRY_TIME) {
throw new InvalidExpiresRangeException(expires, "expires must be in range of 1 to " + DEFAULT_EXPIRY_TIME);
}
byte[] body = null;
if (method == Method.PUT || method == Method.POST) {
body = new byte[0];
}
Multimap<String, String> queryParamMap = null;
if (reqParams != null) {
queryParamMap = HashMultimap.create();
for (Map.Entry<String, String> m: reqParams.entrySet()) {
queryParamMap.put(m.getKey(), m.getValue());
}
}
String region = getRegion(bucketName);
Request request = createRequest(method, bucketName, objectName, region, null, queryParamMap, null, body, 0);
HttpUrl url = Signer.presignV4(request, region, accessKey, secretKey, expires);
return url.toString();
} | java |
public String presignedGetObject(String bucketName, String objectName, Integer expires,
Map<String, String> reqParams)
throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException,
InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException,
InternalException, InvalidExpiresRangeException {
return getPresignedObjectUrl(Method.GET, bucketName, objectName, expires, reqParams);
} | java |
public String presignedGetObject(String bucketName, String objectName, Integer expires)
throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException,
InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException,
InternalException, InvalidExpiresRangeException {
return presignedGetObject(bucketName, objectName, expires, null);
} | java |
public String presignedPutObject(String bucketName, String objectName, Integer expires)
throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException,
InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException,
InternalException, InvalidExpiresRangeException {
return getPresignedObjectUrl(Method.PUT, bucketName, objectName, expires, null);
} | java |
public void removeObject(String bucketName, String objectName)
throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException,
InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException,
InternalException, InvalidArgumentException {
if ((bucketName == null) || (bucketName.isEmpty())) {
throw new InvalidArgumentException("bucket name cannot be empty");
}
if ((objectName == null) || (objectName.isEmpty())) {
throw new InvalidArgumentException("object name cannot be empty");
}
executeDelete(bucketName, objectName, null);
} | java |
public Iterable<Result<Item>> listObjects(final String bucketName) throws XmlPullParserException {
return listObjects(bucketName, null);
} | java |
public Iterable<Result<Item>> listObjects(final String bucketName, final String prefix)
throws XmlPullParserException {
// list all objects recursively
return listObjects(bucketName, prefix, true);
} | java |
public List<Bucket> listBuckets()
throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException,
InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException,
InternalException {
HttpResponse response = executeGet(null, null, null, null);
ListAllMyBucketsResult result = new ListAllMyBucketsResult();
result.parseXml(response.body().charStream());
response.body().close();
return result.buckets();
} | java |
public boolean bucketExists(String bucketName)
throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException,
InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException,
InternalException {
try {
executeHead(bucketName, null);
return true;
} catch (ErrorResponseException e) {
if (e.errorResponse().errorCode() != ErrorCode.NO_SUCH_BUCKET) {
throw e;
}
}
return false;
} | java |
public void makeBucket(String bucketName)
throws InvalidBucketNameException, RegionConflictException, NoSuchAlgorithmException, InsufficientDataException,
IOException, InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException,
InternalException {
this.makeBucket(bucketName, null);
} | java |
public void makeBucket(String bucketName, String region)
throws InvalidBucketNameException, RegionConflictException, NoSuchAlgorithmException, InsufficientDataException,
IOException, InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException,
InternalException {
// If region param is not provided, set it with the one provided by constructor
if (region == null) {
region = this.region;
}
// If constructor already sets a region, check if it is equal to region param if provided
if (this.region != null && !this.region.equals(region)) {
throw new RegionConflictException("passed region conflicts with the one previously specified");
}
String configString;
if (region == null || US_EAST_1.equals(region)) {
// for 'us-east-1', location constraint is not required. for more info
// http://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region
region = US_EAST_1;
configString = "";
} else {
CreateBucketConfiguration config = new CreateBucketConfiguration(region);
configString = config.toString();
}
HttpResponse response = executePut(bucketName, null, null, null, region, configString, 0);
response.body().close();
} | java |
private String putObject(String bucketName, String objectName, int length,
Object data, String uploadId, int partNumber, Map<String, String> headerMap)
throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException,
InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException,
InternalException {
HttpResponse response = null;
Map<String,String> queryParamMap = null;
if (partNumber > 0 && uploadId != null && !"".equals(uploadId)) {
queryParamMap = new HashMap<>();
queryParamMap.put("partNumber", Integer.toString(partNumber));
queryParamMap.put(UPLOAD_ID, uploadId);
}
response = executePut(bucketName, objectName, headerMap, queryParamMap, data, length);
response.body().close();
return response.header().etag();
} | java |
private void putObject(String bucketName, String objectName, Long size, Object data,
Map<String, String> headerMap, ServerSideEncryption sse)
throws InvalidBucketNameException, NoSuchAlgorithmException, IOException,
InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException,
InternalException,
InvalidArgumentException, InsufficientDataException {
boolean unknownSize = false;
// Add content type if not already set
if (headerMap.get("Content-Type") == null) {
headerMap.put("Content-Type", "application/octet-stream");
}
if (size == null) {
unknownSize = true;
size = MAX_OBJECT_SIZE;
}
if (size <= MIN_MULTIPART_SIZE) {
// Single put object.
if (sse != null) {
sse.marshal(headerMap);
}
putObject(bucketName, objectName, size.intValue(), data, null, 0, headerMap);
return;
}
/* Multipart upload */
int[] rv = calculateMultipartSize(size);
int partSize = rv[0];
int partCount = rv[1];
int lastPartSize = rv[2];
Part[] totalParts = new Part[partCount];
// if sse is requested set the necessary headers before we begin the multipart session.
if (sse != null) {
sse.marshal(headerMap);
}
// initiate new multipart upload.
String uploadId = initMultipartUpload(bucketName, objectName, headerMap);
try {
int expectedReadSize = partSize;
for (int partNumber = 1; partNumber <= partCount; partNumber++) {
if (partNumber == partCount) {
expectedReadSize = lastPartSize;
}
// For unknown sized stream, check available size.
int availableSize = 0;
if (unknownSize) {
// Check whether data is available one byte more than expectedReadSize.
availableSize = getAvailableSize(data, expectedReadSize + 1);
// If availableSize is less or equal to expectedReadSize, then we reached last part.
if (availableSize <= expectedReadSize) {
// If it is first part, do single put object.
if (partNumber == 1) {
putObject(bucketName, objectName, availableSize, data, null, 0, headerMap);
return;
}
expectedReadSize = availableSize;
partCount = partNumber;
}
}
// In multi-part uploads, Set encryption headers in the case of SSE-C.
Map<String, String> encryptionHeaders = new HashMap<>();
if (sse != null && sse.getType() == ServerSideEncryption.Type.SSE_C) {
sse.marshal(encryptionHeaders);
}
String etag = putObject(bucketName, objectName, expectedReadSize, data,
uploadId, partNumber, encryptionHeaders);
totalParts[partNumber - 1] = new Part(partNumber, etag);
}
// All parts have been uploaded, complete the multipart upload.
completeMultipart(bucketName, objectName, uploadId, totalParts);
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
abortMultipartUpload(bucketName, objectName, uploadId);
throw e;
}
} | java |
public String getBucketPolicy(String bucketName)
throws InvalidBucketNameException, InvalidObjectPrefixException, NoSuchAlgorithmException,
InsufficientDataException, IOException, InvalidKeyException, NoResponseException,
XmlPullParserException, ErrorResponseException, InternalException, BucketPolicyTooLargeException {
Map<String,String> queryParamMap = new HashMap<>();
queryParamMap.put("policy", "");
HttpResponse response = null;
byte[] buf = new byte[MAX_BUCKET_POLICY_SIZE];
int bytesRead = 0;
try {
response = executeGet(bucketName, null, null, queryParamMap);
bytesRead = response.body().byteStream().read(buf, 0, MAX_BUCKET_POLICY_SIZE);
if (bytesRead < 0) {
// reached EOF
throw new IOException("reached EOF when reading bucket policy");
}
// Read one byte extra to ensure only MAX_BUCKET_POLICY_SIZE data is sent by the server.
if (bytesRead == MAX_BUCKET_POLICY_SIZE) {
int byteRead = 0;
while (byteRead == 0) {
byteRead = response.body().byteStream().read();
if (byteRead < 0) {
// reached EOF which is fine.
break;
} else if (byteRead > 0) {
throw new BucketPolicyTooLargeException(bucketName);
}
}
}
} catch (ErrorResponseException e) {
if (e.errorResponse().errorCode() != ErrorCode.NO_SUCH_BUCKET_POLICY) {
throw e;
}
} finally {
if (response != null && response.body() != null) {
response.body().close();
}
}
return new String(buf, 0, bytesRead, StandardCharsets.UTF_8);
} | java |
public void setBucketPolicy(String bucketName, String policy)
throws InvalidBucketNameException, InvalidObjectPrefixException, NoSuchAlgorithmException,
InsufficientDataException, IOException, InvalidKeyException, NoResponseException,
XmlPullParserException, ErrorResponseException, InternalException {
Map<String,String> headerMap = new HashMap<>();
headerMap.put("Content-Type", "application/json");
Map<String,String> queryParamMap = new HashMap<>();
queryParamMap.put("policy", "");
HttpResponse response = executePut(bucketName, null, headerMap, queryParamMap, policy, 0);
response.body().close();
} | java |
public void deleteBucketLifeCycle(String bucketName)
throws InvalidBucketNameException, NoSuchAlgorithmException,
InsufficientDataException, IOException, InvalidKeyException, NoResponseException,
XmlPullParserException, ErrorResponseException, InternalException {
Map<String,String> queryParamMap = new HashMap<>();
queryParamMap.put("lifecycle", "");
HttpResponse response = executeDelete(bucketName, "", queryParamMap);
response.body().close();
} | java |
public String getBucketLifeCycle(String bucketName)
throws InvalidBucketNameException, NoSuchAlgorithmException,
InsufficientDataException, IOException, InvalidKeyException, NoResponseException,
XmlPullParserException, ErrorResponseException, InternalException {
Map<String,String> queryParamMap = new HashMap<>();
queryParamMap.put("lifecycle", "");
HttpResponse response = null;
String bodyContent = "";
Scanner scanner = null ;
try {
response = executeGet(bucketName, "", null, queryParamMap);
scanner = new Scanner(response.body().charStream());
// read entire body stream to string.
scanner.useDelimiter("\\A");
if (scanner.hasNext()) {
bodyContent = scanner.next();
}
} catch (ErrorResponseException e) {
if (e.errorResponse().errorCode() != ErrorCode.NO_SUCH_LIFECYCLE_CONFIGURATION) {
throw e;
}
} finally {
if (response != null && response.body() != null) {
response.body().close();
}
if (scanner != null) {
scanner.close();
}
}
return bodyContent;
} | java |
public NotificationConfiguration getBucketNotification(String bucketName)
throws InvalidBucketNameException, InvalidObjectPrefixException, NoSuchAlgorithmException,
InsufficientDataException, IOException, InvalidKeyException, NoResponseException,
XmlPullParserException, ErrorResponseException, InternalException {
Map<String,String> queryParamMap = new HashMap<>();
queryParamMap.put("notification", "");
HttpResponse response = executeGet(bucketName, null, null, queryParamMap);
NotificationConfiguration result = new NotificationConfiguration();
try {
result.parseXml(response.body().charStream());
} finally {
response.body().close();
}
return result;
} | java |
public void setBucketNotification(String bucketName, NotificationConfiguration notificationConfiguration)
throws InvalidBucketNameException, InvalidObjectPrefixException, NoSuchAlgorithmException,
InsufficientDataException, IOException, InvalidKeyException, NoResponseException,
XmlPullParserException, ErrorResponseException, InternalException {
Map<String,String> queryParamMap = new HashMap<>();
queryParamMap.put("notification", "");
HttpResponse response = executePut(bucketName, null, null, queryParamMap, notificationConfiguration.toString(), 0);
response.body().close();
} | java |
public void removeAllBucketNotification(String bucketName)
throws InvalidBucketNameException, InvalidObjectPrefixException, NoSuchAlgorithmException,
InsufficientDataException, IOException, InvalidKeyException, NoResponseException,
XmlPullParserException, ErrorResponseException, InternalException {
NotificationConfiguration notificationConfiguration = new NotificationConfiguration();
setBucketNotification(bucketName, notificationConfiguration);
} | java |
public Iterable<Result<Upload>> listIncompleteUploads(String bucketName, String prefix)
throws XmlPullParserException {
return listIncompleteUploads(bucketName, prefix, true, true);
} | java |
private String initMultipartUpload(String bucketName, String objectName, Map<String, String> headerMap)
throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException,
InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException,
InternalException {
// set content type if not set already
if (headerMap.get("Content-Type") == null) {
headerMap.put("Content-Type", "application/octet-stream");
}
Map<String,String> queryParamMap = new HashMap<>();
queryParamMap.put("uploads", "");
HttpResponse response = executePost(bucketName, objectName, headerMap, queryParamMap, "");
InitiateMultipartUploadResult result = new InitiateMultipartUploadResult();
result.parseXml(response.body().charStream());
response.body().close();
return result.uploadId();
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.