conflict_resolution
stringlengths 27
16k
|
|---|
<<<<<<<
import de.fraunhofer.aisec.cpg.graph.type.Type;
import java.util.*;
=======
import de.fraunhofer.aisec.cpg.graph.Type.Origin;
import de.fraunhofer.aisec.cpg.helpers.Util;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
>>>>>>>
import de.fraunhofer.aisec.cpg.graph.Type.Origin;
import de.fraunhofer.aisec.cpg.helpers.Util;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import de.fraunhofer.aisec.cpg.graph.type.Type;
import java.util.*;
<<<<<<<
Type previous = this.type;
List<Type> types =
invokes.stream()
.map(FunctionDeclaration::getType)
.filter(Objects::nonNull)
.collect(Collectors.toList());
Type alternative = !types.isEmpty() ? types.get(0) : null;
Type commonType = TypeManager.getInstance().getCommonType(types).orElse(alternative);
Set<Type> subTypes = new HashSet<>(getPossibleSubTypes());
subTypes.remove(oldType);
subTypes.addAll(types);
setType(commonType, root);
setPossibleSubTypes(subTypes, root);
if (!previous.equals(this.type)) {
this.type.setTypeOrigin(Type.Origin.DATAFLOW);
=======
if (src == base) {
setFqn(src.getType().getTypeName() + "." + this.getName());
} else {
Type previous = this.type;
List<Type> types =
invokes.stream()
.map(FunctionDeclaration::getType)
.filter(Objects::nonNull)
.collect(Collectors.toList());
Type alternative = !types.isEmpty() ? types.get(0) : null;
Type commonType = TypeManager.getInstance().getCommonType(types).orElse(alternative);
Set<Type> subTypes = new HashSet<>(getPossibleSubTypes());
subTypes.remove(oldType);
subTypes.addAll(types);
setType(commonType, root);
setPossibleSubTypes(subTypes, root);
if (!previous.equals(this.type)) {
this.type.setTypeOrigin(Origin.DATAFLOW);
}
>>>>>>>
if (src == base) {
setFqn(src.getType().getTypeName() + "." + this.getName());
} else {
Type previous = this.type;
List<Type> types =
invokes.stream()
.map(FunctionDeclaration::getType)
.filter(Objects::nonNull)
.collect(Collectors.toList());
Type alternative = !types.isEmpty() ? types.get(0) : null;
Type commonType = TypeManager.getInstance().getCommonType(types).orElse(alternative);
Set<Type> subTypes = new HashSet<>(getPossibleSubTypes());
subTypes.remove(oldType);
subTypes.addAll(types);
setType(commonType, root);
setPossibleSubTypes(subTypes, root);
if (!previous.equals(this.type)) {
this.type.setTypeOrigin(Type.Origin.DATAFLOW);
} |
<<<<<<<
import java.util.Deque;
=======
import java.util.Comparator;
>>>>>>>
import java.util.Comparator;
import java.util.Deque;
<<<<<<<
/**
* Split a String into multiple parts by using one or more delimiter characters. Any delimiters
* that are surrounded by matching opening and closing brackets are skipped. E.g. "a,(b,c)" will
* result in a list containing "a" and "(b,c)" when splitting on commas. Empty parts are ignored,
* so when splitting "a,,,,(b,c)", the same result is returned as in the previous example.
*
* @param toSplit The input String
* @param delimiters A String containing all characters that should be treated as delimiters
* @return A list of all parts of the input, as divided by any delimiter
*/
public static List<String> splitLeavingParenthesisContents(String toSplit, String delimiters) {
List<String> result = new ArrayList<>();
int openParentheses = 0;
StringBuilder currPart = new StringBuilder();
for (char c : toSplit.toCharArray()) {
if (c == '(') {
openParentheses++;
currPart.append(c);
} else if (c == ')') {
if (openParentheses > 0) {
openParentheses--;
}
currPart.append(c);
} else if (delimiters.contains("" + c)) {
if (openParentheses == 0) {
String toAdd = currPart.toString().strip();
if (!toAdd.isEmpty()) {
result.add(currPart.toString().strip());
}
currPart = new StringBuilder();
} else {
currPart.append(c);
}
} else {
currPart.append(c);
}
}
if (currPart.length() > 0) {
result.add(currPart.toString().strip());
}
return result;
}
/**
* Removes pairs of parentheses that do not provide any further separation. E.g. "(foo)" results
* in "foo" and "(((foo))((bar)))" in "(foo)(bar)", whereas "(foo)(bar)" stays the same.
*
* @param original The String to clean
* @return The modified version without excess parentheses
*/
public static String removeRedundantParentheses(String original) {
char[] result = original.toCharArray();
char marker = '\uffff';
Deque<Integer> openingParentheses = new ArrayDeque<>();
for (int i = 0; i < original.length(); i++) {
char c = original.charAt(i);
switch (c) {
case '(':
openingParentheses.push(i);
break;
case ')':
int matching = openingParentheses.pop();
if (matching == 0 && i == original.length() - 1) {
result[matching] = result[i] = marker;
} else if (matching > 0 && result[matching - 1] == '(' && result[i + 1] == ')') {
result[matching] = result[i] = marker;
}
}
}
return new String(result).replace("" + marker, "");
}
public static boolean containsOnOuterLevel(String input, char marker) {
int openParentheses = 0;
for (char c : input.toCharArray()) {
if (c == '(') {
openParentheses++;
} else if (c == ')') {
openParentheses--;
} else if (c == marker && openParentheses == 0) {
return true;
}
}
return false;
}
=======
/**
* Establish dataflow from call arguments to the target {@link FunctionDeclaration} parameters
*
* @param target The call's target {@link FunctionDeclaration}
* @param arguments The call's arguments to be connected to the target's parameters
*/
public static void attachCallParameters(FunctionDeclaration target, List<Expression> arguments) {
target.getParameters().sort(Comparator.comparing(ParamVariableDeclaration::getArgumentIndex));
for (int j = 0; j < arguments.size(); j++) {
ParamVariableDeclaration param = target.getParameters().get(j);
if (param.isVariadic()) {
for (; j < arguments.size(); j++) {
// map all the following arguments to this variadic param
param.addPrevDFG(arguments.get(j));
}
break;
} else {
param.addPrevDFG(arguments.get(j));
}
}
}
/**
* Inverse operation of {@link #attachCallParameters}
*
* @param target
* @param arguments
*/
public static void detachCallParameters(FunctionDeclaration target, List<Expression> arguments) {
for (ParamVariableDeclaration param : target.getParameters()) {
// A param could be variadic, so multiple arguments could be set as incoming DFG
param.getPrevDFG().stream().filter(arguments::contains).forEach(param::removeNextDFG);
}
}
>>>>>>>
/**
* Split a String into multiple parts by using one or more delimiter characters. Any delimiters
* that are surrounded by matching opening and closing brackets are skipped. E.g. "a,(b,c)" will
* result in a list containing "a" and "(b,c)" when splitting on commas. Empty parts are ignored,
* so when splitting "a,,,,(b,c)", the same result is returned as in the previous example.
*
* @param toSplit The input String
* @param delimiters A String containing all characters that should be treated as delimiters
* @return A list of all parts of the input, as divided by any delimiter
*/
public static List<String> splitLeavingParenthesisContents(String toSplit, String delimiters) {
List<String> result = new ArrayList<>();
int openParentheses = 0;
StringBuilder currPart = new StringBuilder();
for (char c : toSplit.toCharArray()) {
if (c == '(') {
openParentheses++;
currPart.append(c);
} else if (c == ')') {
if (openParentheses > 0) {
openParentheses--;
}
currPart.append(c);
} else if (delimiters.contains("" + c)) {
if (openParentheses == 0) {
String toAdd = currPart.toString().strip();
if (!toAdd.isEmpty()) {
result.add(currPart.toString().strip());
}
currPart = new StringBuilder();
} else {
currPart.append(c);
}
} else {
currPart.append(c);
}
}
if (currPart.length() > 0) {
result.add(currPart.toString().strip());
}
return result;
}
/**
* Removes pairs of parentheses that do not provide any further separation. E.g. "(foo)" results
* in "foo" and "(((foo))((bar)))" in "(foo)(bar)", whereas "(foo)(bar)" stays the same.
*
* @param original The String to clean
* @return The modified version without excess parentheses
*/
public static String removeRedundantParentheses(String original) {
char[] result = original.toCharArray();
char marker = '\uffff';
Deque<Integer> openingParentheses = new ArrayDeque<>();
for (int i = 0; i < original.length(); i++) {
char c = original.charAt(i);
switch (c) {
case '(':
openingParentheses.push(i);
break;
case ')':
int matching = openingParentheses.pop();
if (matching == 0 && i == original.length() - 1) {
result[matching] = result[i] = marker;
} else if (matching > 0 && result[matching - 1] == '(' && result[i + 1] == ')') {
result[matching] = result[i] = marker;
}
}
}
return new String(result).replace("" + marker, "");
}
public static boolean containsOnOuterLevel(String input, char marker) {
int openParentheses = 0;
for (char c : input.toCharArray()) {
if (c == '(') {
openParentheses++;
} else if (c == ')') {
openParentheses--;
} else if (c == marker && openParentheses == 0) {
return true;
}
}
return false;
}
/**
* Establish dataflow from call arguments to the target {@link FunctionDeclaration} parameters
*
* @param target The call's target {@link FunctionDeclaration}
* @param arguments The call's arguments to be connected to the target's parameters
*/
public static void attachCallParameters(FunctionDeclaration target, List<Expression> arguments) {
target.getParameters().sort(Comparator.comparing(ParamVariableDeclaration::getArgumentIndex));
for (int j = 0; j < arguments.size(); j++) {
ParamVariableDeclaration param = target.getParameters().get(j);
if (param.isVariadic()) {
for (; j < arguments.size(); j++) {
// map all the following arguments to this variadic param
param.addPrevDFG(arguments.get(j));
}
break;
} else {
param.addPrevDFG(arguments.get(j));
}
}
}
/**
* Inverse operation of {@link #attachCallParameters}
*
* @param target
* @param arguments
*/
public static void detachCallParameters(FunctionDeclaration target, List<Expression> arguments) {
for (ParamVariableDeclaration param : target.getParameters()) {
// A param could be variadic, so multiple arguments could be set as incoming DFG
param.getPrevDFG().stream().filter(arguments::contains).forEach(param::removeNextDFG);
}
} |
<<<<<<<
private PreferenceScreen denominationScreen;
private Preference _localCurrency;
private PreferenceScreen exchangeSourceScreen;
private CheckBoxPreference _ltNotificationSound;
private CheckBoxPreference _ltMilesKilometers;
private MbwManager _mbwManager;
private LocalTraderManager _ltManager;
private ListPreference _minerFee;
private PreferenceScreen blockExplorerScreen;
=======
private ListPreference denomination;
private Preference localCurrency;
private ListPreference exchangeSource;
private CheckBoxPreference ltNotificationSound;
private CheckBoxPreference ltMilesKilometers;
private MbwManager mbwManager;
private LocalTraderManager ltManager;
private ListPreference minerFee;
private ListPreference blockExplorer;
>>>>>>>
private PreferenceScreen denominationScreen;
private Preference localCurrency;
private PreferenceScreen exchangeSourceScreen;
private CheckBoxPreference ltNotificationSound;
private CheckBoxPreference ltMilesKilometers;
private MbwManager mbwManager;
private LocalTraderManager ltManager;
private ListPreference minerFee;
private PreferenceScreen blockExplorerScreen;
<<<<<<<
_mbwManager = MbwManager.getInstance(getActivity().getApplication());
_ltManager = _mbwManager.getLocalTraderManager();
// Denomination
denominationScreen = findPreference(Constants.SETTING_DENOMINATION);
=======
mbwManager = MbwManager.getInstance(requireActivity().getApplication());
ltManager = mbwManager.getLocalTraderManager();
displayPreferenceDialogHandler = new DisplayPreferenceDialogHandler(getActivity());
assignPreferences();
}
private void assignPreferences() {
// Bitcoin Denomination
denomination = findPreference(Constants.SETTING_DENOMINATION);
>>>>>>>
mbwManager = MbwManager.getInstance(requireActivity().getApplication());
ltManager = mbwManager.getLocalTraderManager();
displayPreferenceDialogHandler = new DisplayPreferenceDialogHandler(getActivity());
assignPreferences();
}
private void assignPreferences() {
// Denomination
denominationScreen = findPreference(Constants.SETTING_DENOMINATION);
<<<<<<<
blockExplorerScreen = findPreference("block_explorer");
=======
blockExplorer = findPreference("block_explorer");
>>>>>>>
blockExplorerScreen = findPreference("block_explorer");
<<<<<<<
exchangeSourceScreen = findPreference("exchange_source");
language = (ListPreference) findPreference(Constants.LANGUAGE_SETTING);
=======
exchangeSource = findPreference("exchange_source");
language = findPreference(Constants.LANGUAGE_SETTING);
>>>>>>>
exchangeSourceScreen = findPreference("exchange_source");
language = findPreference(Constants.LANGUAGE_SETTING); |
<<<<<<<
private static final int UNKNOWN_INDEX_BACKPRESSURED = -2;
private final LogonDecoder logon = new LogonDecoder();
=======
private final AbstractLogonDecoder acceptorLogon;
>>>>>>>
private static final int UNKNOWN_INDEX_BACKPRESSURED = -2;
private final AbstractLogonDecoder acceptorLogon;
<<<<<<<
final GatewaySessions gatewaySessions,
final Clock clock)
=======
final GatewaySessions gatewaySessions,
final FixDictionary acceptorFixDictionary)
>>>>>>>
final GatewaySessions gatewaySessions,
final Clock clock,
final FixDictionary acceptorFixDictionary)
<<<<<<<
this.clock = clock;
=======
this.acceptorLogon = acceptorFixDictionary.makeLogonDecoder();
>>>>>>>
this.clock = clock;
this.acceptorLogon = acceptorFixDictionary.makeLogonDecoder();
<<<<<<<
if (saveMessage(offset, LogonDecoder.MESSAGE_TYPE, length, sessionId, sequenceIndex, lastReadTimestamp))
=======
if (saveMessage(offset, LOGON_MESSAGE_TYPE, length, sessionId, sequenceIndex))
>>>>>>>
if (saveMessage(offset, LOGON_MESSAGE_TYPE, length, sessionId, sequenceIndex, lastReadTimestamp))
<<<<<<<
logon, connectionId(), gatewaySession, channel);
=======
acceptorLogon, connectionId(), gatewaySession, channel.remoteAddress());
>>>>>>>
acceptorLogon, connectionId(), gatewaySession, channel); |
<<<<<<<
final ErrorHandler remoteThreadErrorHandler = createRemoteThreadErrorHandler(errorHandler);
scheduler.launch(configuration, remoteThreadErrorHandler, monitoringAgent);
=======
scheduler.launch(configuration, errorHandler, monitoringAgent, conductorAgent());
>>>>>>>
final ErrorHandler remoteThreadErrorHandler = createRemoteThreadErrorHandler(errorHandler);
scheduler.launch(configuration, remoteThreadErrorHandler, monitoringAgent, conductorAgent()); |
<<<<<<<
int scrollTo = 0;
switch (_mbwManager.getSelectedAccount().getType()) {
case BCHBIP44:
case BCHSINGLEADDRESS:
actions.add(new ActionButton(getString(R.string.exchange_bch_to_btc), new Runnable() {
@Override
public void run() {
startExchange(new Intent(getActivity(), ExchangeActivity.class));
}
}));
break;
default:
actions.add(new ActionButton(getString(R.string.exchange_altcoins_to_btc), new Runnable() {
@Override
public void run() {
startExchange(new Intent(getActivity(), ChangellyActivity.class));
}
}));
scrollTo = addMyDfs(actions, scrollTo);
if (showButton) {
actions.add(new ActionButton(getString(R.string.gd_buy_sell_button), new Runnable() {
@Override
public void run() {
startActivity(new Intent(getActivity(), BuySellSelectActivity.class));
}
}));
}
}
buttonAdapter.setButtons(actions);
if (scrollTo != 0) {
recyclerView.postDelayed(new ScrollToRunner(scrollTo), 500);
}
}
private int addMyDfs(List<ActionButton> actions, int scrollTo) {
=======
int scrollTo = 1;
actions.add(new ActionButton(getString(R.string.exchange_altcoins_to_btc), new Runnable() {
@Override
public void run() {
startExchange(new Intent(getActivity(), ChangellyActivity.class));
}
}));
>>>>>>>
int scrollTo = 1;
switch (_mbwManager.getSelectedAccount().getType()) {
case BCHBIP44:
case BCHSINGLEADDRESS:
actions.add(new ActionButton(getString(R.string.exchange_bch_to_btc), new Runnable() {
@Override
public void run() {
startExchange(new Intent(getActivity(), ExchangeActivity.class));
}
}));
break;
default:
actions.add(new ActionButton(getString(R.string.exchange_altcoins_to_btc), new Runnable() {
@Override
public void run() {
startExchange(new Intent(getActivity(), ChangellyActivity.class));
}
}));
scrollTo = addMyDfs(actions, scrollTo);
if (showButton) {
actions.add(new ActionButton(getString(R.string.gd_buy_sell_button), new Runnable() {
@Override
public void run() {
startActivity(new Intent(getActivity(), BuySellSelectActivity.class));
}
}));
}
}
buttonAdapter.setButtons(actions);
if (scrollTo != 0) {
recyclerView.postDelayed(new ScrollToRunner(scrollTo), 500);
}
}
private int addMyDfs(List<ActionButton> actions, int scrollTo) {
<<<<<<<
scrollTo = actions.size() - 1;
}
return scrollTo;
=======
scrollTo = 2;
}
if (showButton) {
actions.add(new ActionButton(getString(R.string.gd_buy_sell_button), new Runnable() {
@Override
public void run() {
startActivity(new Intent(getActivity(), BuySellSelectFragment.class));
}
}));
}
buttonAdapter.setButtons(actions);
recyclerView.postDelayed(new ScrollToRunner(scrollTo), 500);
>>>>>>>
scrollTo = actions.size();
}
return scrollTo;
<<<<<<<
//TODO need find more right way to detect is Changelly available
final ExchangeRate exchangeRate = _mbwManager.getExchangeRateManager().getExchangeRate("BCH");
if (exchangeRate == null || exchangeRate.price == null) {
new AlertDialog.Builder(getActivity(), R.style.MyceliumModern_Dialog)
.setMessage(R.string.exchange_service_unavailable)
.setPositiveButton(R.string.button_ok, null)
.create()
.show();
_mbwManager.getExchangeRateManager().requestRefresh();
} else {
startActivity(intent);
}
=======
startActivity(intent);
>>>>>>>
//TODO need find more right way to detect is Changelly available
final ExchangeRate exchangeRate = _mbwManager.getExchangeRateManager().getExchangeRate("BCH");
if (exchangeRate == null || exchangeRate.price == null) {
new AlertDialog.Builder(getActivity(), R.style.MyceliumModern_Dialog)
.setMessage(R.string.exchange_service_unavailable)
.setPositiveButton(R.string.button_ok, null)
.create()
.show();
_mbwManager.getExchangeRateManager().requestRefresh();
} else {
startActivity(intent);
} |
<<<<<<<
protected MetricEventsListenerFactory eventListenersFactory;
=======
private SSLEngineFactory sslEngineFactory;
>>>>>>>
protected MetricEventsListenerFactory eventListenersFactory;
private SSLEngineFactory sslEngineFactory;
<<<<<<<
S server = createServer();
if (null != eventListenersFactory) {
MetricEventsListener<? extends ServerMetricsEvent<?>> listener = newMetricsListener(eventListenersFactory,
server);
server.subscribe(listener);
}
return server;
=======
if(null != sslEngineFactory) {
appendPipelineConfigurator(PipelineConfigurators.<I, O>sslConfigurator(sslEngineFactory));
}
return createServer();
>>>>>>>
if(null != sslEngineFactory) {
appendPipelineConfigurator(PipelineConfigurators.<I, O>sslConfigurator(sslEngineFactory));
}
S server = createServer();
if (null != eventListenersFactory) {
MetricEventsListener<? extends ServerMetricsEvent<?>> listener = newMetricsListener(eventListenersFactory,
server);
server.subscribe(listener);
}
return server; |
<<<<<<<
import io.reactivex.netty.metrics.MetricEventsSubject;
=======
import io.reactivex.netty.pipeline.ssl.SSLEngineFactory;
import io.reactivex.netty.pipeline.ssl.SslPipelineConfigurator;
>>>>>>>
import io.reactivex.netty.metrics.MetricEventsSubject;
import io.reactivex.netty.pipeline.ssl.SSLEngineFactory;
import io.reactivex.netty.pipeline.ssl.SslPipelineConfigurator; |
<<<<<<<
@Test
/**
*
* Load test to prove concurrency issues mainly seen on heavy load.
*
*/
public void assertPermitsAreReleasedWhenMergingObservablesWithExceptions() {
clientRule.startServer(10, true);
MockTcpClientEventListener listener = new MockTcpClientEventListener();
clientRule.getClient().subscribe(listener);
int number_of_iterations = 1;
int numberOfRequests = 3;
makeRequests(number_of_iterations, numberOfRequests);
sleep(clientRule.getPoolConfig().getMaxIdleTimeMillis());
assertThat("Permits should be 10", clientRule.getPoolConfig().getPoolLimitDeterminationStrategy().getAvailablePermits(), equalTo(10));
}
private void sleep(long i) {
try {
Thread.sleep(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private void makeRequests(int number_of_iterations, int numberOfRequests) {
for (int j = 0; j < number_of_iterations; j++) {
//List<Observable<String>> results = new ArrayList<>();
sleep(100);
List<Observable<String>> results = new ArrayList<>();
//Just giving the client some time to recover
sleep(100);
for (int i = 0; i < numberOfRequests; i++) {
results.add(
fromCallable(new Func0<PooledConnection<ByteBuf, ByteBuf>>() {
@Override
public PooledConnection<ByteBuf, ByteBuf> call() {
return clientRule.connect();
}
})
.flatMap(new Func1<PooledConnection<ByteBuf, ByteBuf>, Observable<String>>() {
@Override
public Observable<String> call(PooledConnection<ByteBuf, ByteBuf> connection) {
return connection.writeStringAndFlushOnEach(just("Hello"))
.toCompletable()
.<ByteBuf>toObservable()
.concatWith(connection.getInput())
.take(1)
.single()
.map(new Func1<ByteBuf, String>() {
@Override
public String call(ByteBuf byteBuf) {
try {
byte[] bytes = new byte[byteBuf.readableBytes()];
byteBuf.readBytes(bytes);
return new String(bytes);
} finally {
byteBuf.release();
}
}
});
}
}));
}
AssertableSubscriber<String> test = Observable.merge(results).test();
test.awaitTerminalEvent();
}
}
=======
@Test
/**
*
* Load test to prove concurrency issues mainly seen on heavy load.
*
*/
public void testLoad() {
clientRule.startServer(1000);
MockTcpClientEventListener listener = new MockTcpClientEventListener();
clientRule.getClient().subscribe(listener);
int number_of_iterations = 300;
int numberOfRequests = 10;
for(int j = 0; j < number_of_iterations; j++) {
List<Observable<String>> results = new ArrayList<>();
//Just giving the client some time to recover
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 0; i < numberOfRequests; i++) {
results.add(
fromCallable(new Func0<PooledConnection<ByteBuf, ByteBuf>>() {
@Override
public PooledConnection<ByteBuf, ByteBuf> call() {
return clientRule.connectWithCheck();
}
})
.flatMap(new Func1<PooledConnection<ByteBuf, ByteBuf>, Observable<String>>() {
@Override
public Observable<String> call(PooledConnection<ByteBuf, ByteBuf> connection) {
return connection.writeStringAndFlushOnEach(just("Hello"))
.toCompletable()
.<ByteBuf>toObservable()
.concatWith(connection.getInput())
.take(1)
.single()
.map(new Func1<ByteBuf, String>() {
@Override
public String call(ByteBuf byteBuf) {
try {
byte[] bytes = new byte[byteBuf.readableBytes()];
byteBuf.readBytes(bytes);
String result = new String(bytes);
return result;
} finally {
byteBuf.release();
}
}
}).doOnError(new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
Assert.fail("Did not expect exception: " + throwable.getMessage());
throwable.printStackTrace();
}
});
}
}));
}
AssertableSubscriber<String> test = Observable.merge(results).test();
test.awaitTerminalEvent();
test.assertNoErrors();
}
}
>>>>>>>
@Test
/**
*
* Load test to prove concurrency issues mainly seen on heavy load.
*
*/
public void testLoad() {
clientRule.startServer(1000);
MockTcpClientEventListener listener = new MockTcpClientEventListener();
clientRule.getClient().subscribe(listener);
int number_of_iterations = 300;
int numberOfRequests = 10;
for(int j = 0; j < number_of_iterations; j++) {
List<Observable<String>> results = new ArrayList<>();
//Just giving the client some time to recover
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 0; i < numberOfRequests; i++) {
results.add(
fromCallable(new Func0<PooledConnection<ByteBuf, ByteBuf>>() {
@Override
public PooledConnection<ByteBuf, ByteBuf> call() {
return clientRule.connectWithCheck();
}
})
.flatMap(new Func1<PooledConnection<ByteBuf, ByteBuf>, Observable<String>>() {
@Override
public Observable<String> call(PooledConnection<ByteBuf, ByteBuf> connection) {
return connection.writeStringAndFlushOnEach(just("Hello"))
.toCompletable()
.<ByteBuf>toObservable()
.concatWith(connection.getInput())
.take(1)
.single()
.map(new Func1<ByteBuf, String>() {
@Override
public String call(ByteBuf byteBuf) {
try {
byte[] bytes = new byte[byteBuf.readableBytes()];
byteBuf.readBytes(bytes);
String result = new String(bytes);
return result;
} finally {
byteBuf.release();
}
}
}).doOnError(new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
Assert.fail("Did not expect exception: " + throwable.getMessage());
throwable.printStackTrace();
}
});
}
}));
}
AssertableSubscriber<String> test = Observable.merge(results).test();
test.awaitTerminalEvent();
test.assertNoErrors();
}
}
@Test
/**
*
* Load test to prove concurrency issues mainly seen on heavy load.
*
*/
public void assertPermitsAreReleasedWhenMergingObservablesWithExceptions() {
clientRule.startServer(10, true);
MockTcpClientEventListener listener = new MockTcpClientEventListener();
clientRule.getClient().subscribe(listener);
int number_of_iterations = 1;
int numberOfRequests = 3;
makeRequests(number_of_iterations, numberOfRequests);
sleep(clientRule.getPoolConfig().getMaxIdleTimeMillis());
assertThat("Permits should be 10", clientRule.getPoolConfig().getPoolLimitDeterminationStrategy().getAvailablePermits(), equalTo(10));
}
private void sleep(long i) {
try {
Thread.sleep(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private void makeRequests(int number_of_iterations, int numberOfRequests) {
for (int j = 0; j < number_of_iterations; j++) {
//List<Observable<String>> results = new ArrayList<>();
sleep(100);
List<Observable<String>> results = new ArrayList<>();
//Just giving the client some time to recover
sleep(100);
for (int i = 0; i < numberOfRequests; i++) {
results.add(
fromCallable(new Func0<PooledConnection<ByteBuf, ByteBuf>>() {
@Override
public PooledConnection<ByteBuf, ByteBuf> call() {
return clientRule.connect();
}
})
.flatMap(new Func1<PooledConnection<ByteBuf, ByteBuf>, Observable<String>>() {
@Override
public Observable<String> call(PooledConnection<ByteBuf, ByteBuf> connection) {
return connection.writeStringAndFlushOnEach(just("Hello"))
.toCompletable()
.<ByteBuf>toObservable()
.concatWith(connection.getInput())
.take(1)
.single()
.map(new Func1<ByteBuf, String>() {
@Override
public String call(ByteBuf byteBuf) {
try {
byte[] bytes = new byte[byteBuf.readableBytes()];
byteBuf.readBytes(bytes);
return new String(bytes);
} finally {
byteBuf.release();
}
}
});
}
}));
}
AssertableSubscriber<String> test = Observable.merge(results).test();
test.awaitTerminalEvent();
}
} |
<<<<<<<
public B withName(String name) {
this.name = name;
return returnBuilder();
}
public B withMetricEventsListenerFactory(MetricEventsListenerFactory eventListenersFactory) {
this.eventListenersFactory = eventListenersFactory;
return returnBuilder();
}
=======
/**
* Overrides all the connection pool settings done previous to this call and disables connection pooling for this
* client, unless enabled again after this call returns.
*
* @return This builder.
*/
public B withNoConnectionPooling() {
poolBuilder = null;
return returnBuilder();
}
>>>>>>>
public B withName(String name) {
this.name = name;
return returnBuilder();
}
public B withMetricEventsListenerFactory(MetricEventsListenerFactory eventListenersFactory) {
this.eventListenersFactory = eventListenersFactory;
return returnBuilder();
}
/**
* Overrides all the connection pool settings done previous to this call and disables connection pooling for this
* client, unless enabled again after this call returns.
*
* @return This builder.
*/
public B withNoConnectionPooling() {
poolBuilder = null;
return returnBuilder();
} |
<<<<<<<
* @author Luis Felipe Vega
* @author Jesús Ascama Arias
=======
* @author Manuel Tejeda
>>>>>>>
* @author Luis Felipe Vega
* @author Jesús Ascama Arias
* @author Manuel Tejeda
<<<<<<<
@Test
public void connectionDenied() {
UsernamePasswordMetadata credentials = new UsernamePasswordMetadata("user", "password");
this.requester = requester()
.setupMetadata(credentials, UsernamePasswordMetadata.BASIC_AUTHENTICATION_MIME_TYPE)
.connectTcp(this.server.address().getHostName(), this.server.address().getPort())
.block();
assertThatCode(() -> this.requester.route("prohibit")
.data("data")
.retrieveMono(String.class)
.block())
.isInstanceOf(ApplicationErrorException.class);
}
=======
@Test
public void connectWithAnyRole() {
UsernamePasswordMetadata credentials =
new UsernamePasswordMetadata("user", "password");
this.requester = requester()
.setupMetadata(credentials, UsernamePasswordMetadata.BASIC_AUTHENTICATION_MIME_TYPE)
.connectTcp(this.server.address().getHostName(), this.server.address().getPort())
.block();
String hiRob = this.requester.route("anyroute")
.data("rob")
.retrieveMono(String.class)
.block();
assertThat(hiRob).isEqualTo("Hi rob");
}
>>>>>>>
@Test
public void connectionDenied() {
UsernamePasswordMetadata credentials = new UsernamePasswordMetadata("user", "password");
this.requester = requester()
.setupMetadata(credentials, UsernamePasswordMetadata.BASIC_AUTHENTICATION_MIME_TYPE)
.connectTcp(this.server.address().getHostName(), this.server.address().getPort())
.block();
assertThatCode(() -> this.requester.route("prohibit")
.data("data")
.retrieveMono(String.class)
.block())
.isInstanceOf(ApplicationErrorException.class);
}
@Test
public void connectWithAnyRole() {
UsernamePasswordMetadata credentials =
new UsernamePasswordMetadata("user", "password");
this.requester = requester()
.setupMetadata(credentials, UsernamePasswordMetadata.BASIC_AUTHENTICATION_MIME_TYPE)
.connectTcp(this.server.address().getHostName(), this.server.address().getPort())
.block();
String hiRob = this.requester.route("anyroute")
.data("rob")
.retrieveMono(String.class)
.block();
assertThat(hiRob).isEqualTo("Hi rob");
}
<<<<<<<
.route("secure.authority.*").hasAuthority("ROLE_USER")
.route("prohibit").denyAll()
=======
.route("anyroute").hasAnyRole("USER")
>>>>>>>
.route("secure.authority.*").hasAuthority("ROLE_USER")
.route("prohibit").denyAll() |
<<<<<<<
* @author Luis Felipe Vega
* @author Jesús Ascama Arias
* @author Manuel Tejeda
=======
* @author Ebert Toribio
>>>>>>>
* @author Luis Felipe Vega
* @author Jesús Ascama Arias
* @author Manuel Tejeda
* @author Ebert Toribio
<<<<<<<
@Test
public void connectionDenied() {
UsernamePasswordMetadata credentials = new UsernamePasswordMetadata("user", "password");
this.requester = requester()
.setupMetadata(credentials, UsernamePasswordMetadata.BASIC_AUTHENTICATION_MIME_TYPE)
.connectTcp(this.server.address().getHostName(), this.server.address().getPort())
.block();
assertThatCode(() -> this.requester.route("prohibit")
.data("data")
.retrieveMono(String.class)
.block())
.isInstanceOf(ApplicationErrorException.class);
}
@Test
public void connectWithAnyRole() {
UsernamePasswordMetadata credentials =
new UsernamePasswordMetadata("user", "password");
this.requester = requester()
.setupMetadata(credentials, UsernamePasswordMetadata.BASIC_AUTHENTICATION_MIME_TYPE)
.connectTcp(this.server.address().getHostName(), this.server.address().getPort())
.block();
String hiRob = this.requester.route("anyroute")
.data("rob")
.retrieveMono(String.class)
.block();
assertThat(hiRob).isEqualTo("Hi rob");
}
=======
@Test
public void connectWithAnyAuthority() {
UsernamePasswordMetadata credentials =
new UsernamePasswordMetadata("ebert", "ebert");
this.requester = requester()
.setupMetadata(credentials, UsernamePasswordMetadata.BASIC_AUTHENTICATION_MIME_TYPE)
.connectTcp(this.server.address().getHostName(), this.server.address().getPort())
.block();
String hiEbert = this.requester.route("management.users")
.data("ebert")
.retrieveMono(String.class)
.block();
assertThat(hiEbert).isEqualTo("Hi ebert");
}
>>>>>>>
@Test
public void connectionDenied() {
UsernamePasswordMetadata credentials = new UsernamePasswordMetadata("user", "password");
this.requester = requester()
.setupMetadata(credentials, UsernamePasswordMetadata.BASIC_AUTHENTICATION_MIME_TYPE)
.connectTcp(this.server.address().getHostName(), this.server.address().getPort())
.block();
assertThatCode(() -> this.requester.route("prohibit")
.data("data")
.retrieveMono(String.class)
.block())
.isInstanceOf(ApplicationErrorException.class);
}
@Test
public void connectWithAnyRole() {
UsernamePasswordMetadata credentials =
new UsernamePasswordMetadata("user", "password");
this.requester = requester()
.setupMetadata(credentials, UsernamePasswordMetadata.BASIC_AUTHENTICATION_MIME_TYPE)
.connectTcp(this.server.address().getHostName(), this.server.address().getPort())
.block();
String hiRob = this.requester.route("anyroute")
.data("rob")
.retrieveMono(String.class)
.block();
assertThat(hiRob).isEqualTo("Hi rob");
}
@Test
public void connectWithAnyAuthority() {
UsernamePasswordMetadata credentials =
new UsernamePasswordMetadata("admin", "password");
this.requester = requester()
.setupMetadata(credentials, UsernamePasswordMetadata.BASIC_AUTHENTICATION_MIME_TYPE)
.connectTcp(this.server.address().getHostName(), this.server.address().getPort())
.block();
String hiEbert = this.requester.route("management.users")
.data("admin")
.retrieveMono(String.class)
.block();
assertThat(hiEbert).isEqualTo("Hi admin");
}
<<<<<<<
.route("secure.authority.*").hasAuthority("ROLE_USER")
.route("prohibit").denyAll()
=======
.route("management.*").hasAnyAuthority("ROLE_MANAGER")
>>>>>>>
.route("secure.authority.*").hasAuthority("ROLE_USER")
.route("management.*").hasAnyAuthority("ROLE_ADMIN")
.route("prohibit").denyAll() |
<<<<<<<
private void doShowDetails(GenericTransactionSummary selected) {
=======
@Subscribe
public void tooManyTx(TooManyTransactions event) {
accountsWithPartialHistory.add(event.getAccountId());
}
private void doShowDetails(TransactionSummary selected) {
>>>>>>>
@Subscribe
public void tooManyTx(TooManyTransactions event) {
accountsWithPartialHistory.add(event.getAccountId());
}
private void doShowDetails(GenericTransactionSummary selected) {
<<<<<<<
public void OnAddressLabelChanged(String address, String label) {
MbwManager.getEventBus().post(new AddressBookChanged());
=======
public void OnAddressLabelChanged(Address address, String label) {
MbwManager.getEventBus().post(new AddressBookChanged());
>>>>>>>
public void OnAddressLabelChanged(String address, String label) {
MbwManager.getEventBus().post(new AddressBookChanged()); |
<<<<<<<
import java.util.ArrayList;
import java.util.List;
import io.rsocket.core.RSocketServer;
=======
import java.util.ArrayList;
import java.util.List;
import io.rsocket.RSocketFactory;
import io.rsocket.exceptions.RejectedSetupException;
>>>>>>>
import java.util.ArrayList;
import java.util.List;
import io.rsocket.core.RSocketServer;
import io.rsocket.exceptions.RejectedSetupException;
<<<<<<<
this.server = RSocketServer.create()
.payloadDecoder(PayloadDecoder.ZERO_COPY)
.interceptors((registry) -> {
registry.forSocketAcceptor(this.interceptor);
})
.acceptor(this.handler.responder())
.bind(TcpServerTransport.create("localhost", 0))
.block();
=======
// @formatter:off
this.server = RSocketFactory.receive()
.frameDecoder(PayloadDecoder.ZERO_COPY)
.addSocketAcceptorPlugin(this.interceptor)
.acceptor(this.handler.responder())
.transport(TcpServerTransport.create("localhost", 0))
.start()
.block();
// @formatter:on
>>>>>>>
// @formatter:off
this.server = RSocketServer.create()
.payloadDecoder(PayloadDecoder.ZERO_COPY)
.interceptors((registry) ->
registry.forSocketAcceptor(this.interceptor)
)
.acceptor(this.handler.responder())
.bind(TcpServerTransport.create("localhost", 0))
.block();
// @formatter:on |
<<<<<<<
=======
import org.opensaml.saml.common.assertion.ValidationResult;
import org.opensaml.saml.saml2.assertion.SAML2AssertionValidationParameters;
import org.opensaml.saml.saml2.assertion.impl.OneTimeUseConditionValidator;
>>>>>>>
import org.opensaml.saml.saml2.assertion.SAML2AssertionValidationParameters;
<<<<<<<
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
=======
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
>>>>>>>
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
<<<<<<<
import static org.mockito.Mockito.when;
import static org.opensaml.core.xml.config.XMLObjectProviderRegistrySupport.getBuilderFactory;
import static org.opensaml.core.xml.config.XMLObjectProviderRegistrySupport.getMarshallerFactory;
import static org.opensaml.saml.saml2.assertion.SAML2AssertionValidationParameters.SC_VALID_RECIPIENTS;
import static org.springframework.security.saml2.core.Saml2ErrorCodes.INVALID_ASSERTION;
import static org.springframework.security.saml2.core.Saml2ErrorCodes.INVALID_SIGNATURE;
import static org.springframework.security.saml2.core.Saml2ResponseValidatorResult.success;
import static org.springframework.security.saml2.credentials.TestSaml2X509Credentials.assertingPartyEncryptingCredential;
import static org.springframework.security.saml2.credentials.TestSaml2X509Credentials.assertingPartyPrivateCredential;
import static org.springframework.security.saml2.credentials.TestSaml2X509Credentials.assertingPartySigningCredential;
import static org.springframework.security.saml2.credentials.TestSaml2X509Credentials.relyingPartyDecryptingCredential;
import static org.springframework.security.saml2.credentials.TestSaml2X509Credentials.relyingPartyVerifyingCredential;
import static org.springframework.security.saml2.provider.service.authentication.OpenSamlAuthenticationProvider.createDefaultAssertionValidator;
import static org.springframework.security.saml2.provider.service.authentication.OpenSamlAuthenticationProvider.createDefaultResponseAuthenticationConverter;
import static org.springframework.security.saml2.provider.service.authentication.TestOpenSamlObjects.assertion;
import static org.springframework.security.saml2.provider.service.authentication.TestOpenSamlObjects.attributeStatements;
import static org.springframework.security.saml2.provider.service.authentication.TestOpenSamlObjects.encrypted;
import static org.springframework.security.saml2.provider.service.authentication.TestOpenSamlObjects.response;
import static org.springframework.security.saml2.provider.service.authentication.TestOpenSamlObjects.signed;
import static org.springframework.security.saml2.provider.service.authentication.TestOpenSamlObjects.signedResponseWithOneAssertion;
import static org.springframework.util.StringUtils.hasText;
=======
>>>>>>>
<<<<<<<
=======
public void authenticateWhenAttributeValueMarshallerConfiguredThenUses() throws Exception {
Response response = TestOpenSamlObjects.response();
Assertion assertion = TestOpenSamlObjects.assertion();
List<AttributeStatement> attributes = TestOpenSamlObjects.attributeStatements();
assertion.getAttributeStatements().addAll(attributes);
TestOpenSamlObjects.signed(assertion, TestSaml2X509Credentials.assertingPartySigningCredential(),
RELYING_PARTY_ENTITY_ID);
response.getAssertions().add(assertion);
Saml2AuthenticationToken token = token(response, TestSaml2X509Credentials.relyingPartyVerifyingCredential());
Element attributeElement = element("<element>value</element>");
Marshaller marshaller = mock(Marshaller.class);
given(marshaller.marshall(any(XMLObject.class))).willReturn(attributeElement);
try {
XMLObjectProviderRegistrySupport.getMarshallerFactory()
.registerMarshaller(AttributeValue.DEFAULT_ELEMENT_NAME, marshaller);
this.provider.authenticate(token);
verify(marshaller, atLeastOnce()).marshall(any(XMLObject.class));
}
finally {
XMLObjectProviderRegistrySupport.getMarshallerFactory()
.deregisterMarshaller(AttributeValue.DEFAULT_ELEMENT_NAME);
}
}
@Test
>>>>>>>
<<<<<<<
provider.setAssertionValidator(assertionToken ->
createDefaultAssertionValidator(token -> new ValidationContext()).convert(assertionToken)
.concat(new Saml2Error("wrong error", "wrong error")));
Response response = response();
Assertion assertion = assertion();
=======
provider.setConditionValidators(Collections.singleton(validator));
Response response = TestOpenSamlObjects.response();
Assertion assertion = TestOpenSamlObjects.assertion();
>>>>>>>
// @formatter:off
provider.setAssertionValidator((assertionToken) -> OpenSamlAuthenticationProvider
.createDefaultAssertionValidator((token) -> new ValidationContext())
.convert(assertionToken)
.concat(new Saml2Error("wrong error", "wrong error"))
);
// @formatter:on
Response response = TestOpenSamlObjects.response();
Assertion assertion = TestOpenSamlObjects.assertion();
<<<<<<<
signed(response, assertingPartySigningCredential(), ASSERTING_PARTY_ENTITY_ID);
Saml2AuthenticationToken token = token(response, relyingPartyVerifyingCredential());
assertThatThrownBy(() -> provider.authenticate(token))
.isInstanceOf(Saml2AuthenticationException.class)
.hasFieldOrPropertyWithValue("error.errorCode", INVALID_ASSERTION);
}
@Test
public void authenticateWhenCustomAssertionValidatorThenUses() {
Converter<OpenSamlAuthenticationProvider.AssertionToken, Saml2ResponseValidatorResult> validator =
mock(Converter.class);
OpenSamlAuthenticationProvider provider = new OpenSamlAuthenticationProvider();
provider.setAssertionValidator(assertionToken ->
createDefaultAssertionValidator().convert(assertionToken)
.concat(validator.convert(assertionToken)));
Response response = response();
Assertion assertion = assertion();
response.getAssertions().add(assertion);
signed(response, assertingPartySigningCredential(), ASSERTING_PARTY_ENTITY_ID);
Saml2AuthenticationToken token = token(response, relyingPartyVerifyingCredential());
when(validator.convert(any(OpenSamlAuthenticationProvider.AssertionToken.class)))
.thenReturn(success());
=======
TestOpenSamlObjects.signed(response, TestSaml2X509Credentials.assertingPartySigningCredential(),
ASSERTING_PARTY_ENTITY_ID);
Saml2AuthenticationToken token = token(response, TestSaml2X509Credentials.relyingPartyVerifyingCredential());
given(validator.getServicedCondition()).willReturn(OneTimeUse.DEFAULT_ELEMENT_NAME);
given(validator.validate(any(Condition.class), any(Assertion.class), any(ValidationContext.class)))
.willReturn(ValidationResult.VALID);
>>>>>>>
TestOpenSamlObjects.signed(response, TestSaml2X509Credentials.assertingPartySigningCredential(),
ASSERTING_PARTY_ENTITY_ID);
Saml2AuthenticationToken token = token(response, TestSaml2X509Credentials.relyingPartyVerifyingCredential());
// @formatter:off
assertThatExceptionOfType(Saml2AuthenticationException.class)
.isThrownBy(() -> provider.authenticate(token)).isInstanceOf(Saml2AuthenticationException.class)
.satisfies((error) -> assertThat(error.getSaml2Error().getErrorCode()).isEqualTo(Saml2ErrorCodes.INVALID_ASSERTION));
// @formatter:on
}
@Test
public void authenticateWhenCustomAssertionValidatorThenUses() {
Converter<OpenSamlAuthenticationProvider.AssertionToken, Saml2ResponseValidatorResult> validator = mock(
Converter.class);
OpenSamlAuthenticationProvider provider = new OpenSamlAuthenticationProvider();
// @formatter:off
provider.setAssertionValidator((assertionToken) -> OpenSamlAuthenticationProvider.createDefaultAssertionValidator()
.convert(assertionToken)
.concat(validator.convert(assertionToken))
);
// @formatter:on
Response response = TestOpenSamlObjects.response();
Assertion assertion = TestOpenSamlObjects.assertion();
response.getAssertions().add(assertion);
TestOpenSamlObjects.signed(response, TestSaml2X509Credentials.assertingPartySigningCredential(),
ASSERTING_PARTY_ENTITY_ID);
Saml2AuthenticationToken token = token(response, TestSaml2X509Credentials.relyingPartyVerifyingCredential());
given(validator.convert(any(OpenSamlAuthenticationProvider.AssertionToken.class)))
.willReturn(Saml2ResponseValidatorResult.success());
<<<<<<<
parameters.put(SC_VALID_RECIPIENTS, singleton("blah"));
=======
parameters.put(SAML2AssertionValidationParameters.SC_VALID_RECIPIENTS, Collections.singleton(DESTINATION));
parameters.put(SAML2AssertionValidationParameters.SIGNATURE_REQUIRED, false);
>>>>>>>
parameters.put(SAML2AssertionValidationParameters.SC_VALID_RECIPIENTS, Collections.singleton("blah"));
<<<<<<<
=======
private static Element element(String xml) throws Exception {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse(new InputSource(new StringReader(xml)));
return doc.getDocumentElement();
}
>>>>>>> |
<<<<<<<
=======
import com.spotify.docker.client.exceptions.ImageNotFoundException;
>>>>>>>
import com.spotify.docker.client.exceptions.ImageNotFoundException;
<<<<<<<
dockerClient, log, verbose, contextDirectory.toPath(), dockerfilePath, repository, tag,
pullNewerImage, noCache, buildArgs);
=======
dockerClient, log, verbose, contextDirectory, repository, tag, pullNewerImage, noCache,
buildArgs, cacheFrom, squash);
>>>>>>>
dockerClient, log, verbose, contextDirectory.toPath(), dockerfilePath, repository, tag,
pullNewerImage, noCache, buildArgs, cacheFrom, squash);
<<<<<<<
private static void requireValidDockerFilePath(@Nonnull Log log,
@Nonnull Path contextDirectory,
@Nullable Path dockerfile)
throws MojoFailureException {
log.info("Path(dockerfile): " + dockerfile);
log.info("Path(contextDirectory): " + contextDirectory);
if (dockerfile == null
&& !Files.exists(contextDirectory.resolve("Dockerfile"))
&& !Files.exists(contextDirectory.resolve("dockerfile"))) {
// user did not override the default value
log.error("Missing Dockerfile in context directory: " + contextDirectory);
throw new MojoFailureException("Missing Dockerfile in context directory: "
+ contextDirectory);
}
if (dockerfile != null) {
if (!Files.exists(dockerfile)) {
log.error("Missing Dockerfile at " + dockerfile);
throw new MojoFailureException("Missing Dockerfile at " + dockerfile);
}
if (!dockerfile.startsWith(contextDirectory)) {
log.error("Dockerfile " + dockerfile + " is not a child of the context directory: "
+ contextDirectory);
throw new MojoFailureException("Dockerfile " + dockerfile
+ " is not a child of the context directory: " + contextDirectory);
}
}
}
=======
private static String encodeBuildParam(Object buildParam) throws MojoExecutionException {
try {
return URLEncoder.encode(new Gson().toJson(buildParam), "utf-8");
} catch (UnsupportedEncodingException e) {
throw new MojoExecutionException("Could not build image", e);
}
}
private static boolean imageExistLocally(DockerClient dockerClient, String image)
throws DockerException, InterruptedException {
try {
dockerClient.inspectImage(image);
return true;
} catch (ImageNotFoundException e) {
return false;
}
}
>>>>>>>
private static void requireValidDockerFilePath(@Nonnull Log log,
@Nonnull Path contextDirectory,
@Nullable Path dockerfile)
throws MojoFailureException {
log.info("Path(dockerfile): " + dockerfile);
log.info("Path(contextDirectory): " + contextDirectory);
if (dockerfile == null
&& !Files.exists(contextDirectory.resolve("Dockerfile"))
&& !Files.exists(contextDirectory.resolve("dockerfile"))) {
// user did not override the default value
log.error("Missing Dockerfile in context directory: " + contextDirectory);
throw new MojoFailureException("Missing Dockerfile in context directory: "
+ contextDirectory);
}
if (dockerfile != null) {
if (!Files.exists(dockerfile)) {
log.error("Missing Dockerfile at " + dockerfile);
throw new MojoFailureException("Missing Dockerfile at " + dockerfile);
}
if (!dockerfile.startsWith(contextDirectory)) {
log.error("Dockerfile " + dockerfile + " is not a child of the context directory: "
+ contextDirectory);
throw new MojoFailureException("Dockerfile " + dockerfile
+ " is not a child of the context directory: " + contextDirectory);
}
}
}
private static String encodeBuildParam(Object buildParam) throws MojoExecutionException {
try {
return URLEncoder.encode(new Gson().toJson(buildParam), "utf-8");
} catch (UnsupportedEncodingException e) {
throw new MojoExecutionException("Could not build image", e);
}
}
private static boolean imageExistLocally(DockerClient dockerClient, String image)
throws DockerException, InterruptedException {
try {
dockerClient.inspectImage(image);
return true;
} catch (ImageNotFoundException e) {
return false;
}
} |
<<<<<<<
private Value _maxSpendableAmount;
=======
private ExactCurrencyValue _maxSpendableAmount;
private Address destinationAddress;
>>>>>>>
private Value _maxSpendableAmount;
private Address destinationAddress;
<<<<<<<
public static void callMeToSend(Activity currentActivity, int requestCode, UUID account, Value amountToSend, Long kbMinerFee,
AccountDisplayType currencyType, boolean isColdStorage)
=======
public static void callMeToSend(Activity currentActivity, int requestCode, UUID account, CurrencyValue amountToSend, Long kbMinerFee,
AccountDisplayType currencyType, boolean isColdStorage, Address destinationAddress)
>>>>>>>
public static void callMeToSend(Activity currentActivity, int requestCode, UUID account, Value amountToSend, Long kbMinerFee,
AccountDisplayType currencyType, boolean isColdStorage, Address destinationAddress)
<<<<<<<
// todo max
// _maxSpendableAmount = _account.calculateMaxSpendableAmount(_kbMinerFee);
// showMaxAmount();
=======
destinationAddress = (Address) getIntent().getSerializableExtra(DESTINATION_ADDRESS);
if (destinationAddress == null) {
destinationAddress = Address.getNullAddress(_mbwManager.getNetwork());
}
_maxSpendableAmount = _account.calculateMaxSpendableAmount(_kbMinerFee, destinationAddress);
showMaxAmount();
>>>>>>>
destinationAddress = (Address) getIntent().getSerializableExtra(DESTINATION_ADDRESS);
if (destinationAddress == null) {
destinationAddress = Address.getNullAddress(_mbwManager.getNetwork());
}
_maxSpendableAmount = _account.calculateMaxSpendableAmount(_kbMinerFee, destinationAddress);
showMaxAmount();
<<<<<<<
Address address = Address.getNullAddress(_mbwManager.getNetwork());
WalletAccount.Receiver receiver = new WalletAccount.Receiver(AddressUtils.fromAddress(address), satoshis);
=======
WalletAccount.Receiver receiver = new WalletAccount.Receiver(Address.getNullAddress(_mbwManager.getNetwork(),
destinationAddress.getType()), satoshis);
>>>>>>>
Address address = Address.getNullAddress(_mbwManager.getNetwork());
WalletAccount.Receiver receiver = new WalletAccount.Receiver(Address.getNullAddress(_mbwManager.getNetwork(),
destinationAddress.getType()), satoshis); |
<<<<<<<
return domainModelDescriptor.getFieldValue(dirtyObject, fieldName) != null;
} else {
return true;
}
=======
return !domainModelDescriptor.getFieldValue(dirtyObject, fieldName).isNull();
} else return true;
>>>>>>>
return !domainModelDescriptor.getFieldValue(dirtyObject, fieldName).isNull();
} else {
return true;
} |
<<<<<<<
return textElement(PUBLISHED, DateSerializer.toString(entity.getPublished()));
=======
return textElement("published", DateSerializer.toString(dateFormat, entity.getPublished()));
>>>>>>>
return textElement(PUBLISHED, DateSerializer.toString(dateFormat, entity.getPublished()));
<<<<<<<
return textElement(UPDATED, DateSerializer.toString(entity.getUpdated()));
=======
return textElement("updated", DateSerializer.toString(dateFormat, entity.getUpdated()));
>>>>>>>
return textElement(UPDATED, DateSerializer.toString(dateFormat, entity.getUpdated())); |
<<<<<<<
//since uuid is used for account creation we can check hdKeynode uuid for account existence
if (_mbwManager.getWalletManager(false).getAccount(legacyFioNode.getUuid()) == null) {
ArrayList<HdKeyNode> nodes = new ArrayList<HdKeyNode>() {{
add(legacyFioNode);
}};
List<UUID> account = _mbwManager.getWalletManager(false).createAccounts(new FIOUnrelatedHDConfig(nodes));
finishOk(account.get(0), false);
} else {
new Toaster(this).toast(R.string.fio_legacy_already_created, false);
}
=======
ArrayList<HdKeyNode> nodes= new ArrayList<HdKeyNode>(){{add(legacyFioNode);}};
List<UUID> account = _mbwManager.getWalletManager(false)
.createAccounts(new FIOUnrelatedHDConfig(nodes, getString(R.string.base_label_fio_account_legacy)));
finishOk(account.get(0), false);
>>>>>>>
//since uuid is used for account creation we can check hdKeynode uuid for account existence
if (_mbwManager.getWalletManager(false).getAccount(legacyFioNode.getUuid()) == null) {
ArrayList<HdKeyNode> nodes = new ArrayList<HdKeyNode>() {{
add(legacyFioNode);
}};
List<UUID> account = _mbwManager.getWalletManager(false).createAccounts(new FIOUnrelatedHDConfig(nodes, getString(R.string.base_label_fio_account_legacy)));
finishOk(account.get(0), false);
} else {
new Toaster(this).toast(R.string.fio_legacy_already_created, false);
} |
<<<<<<<
=======
import com.mycelium.wapi.wallet.fio.FIOOBTransaction;
import com.mycelium.wapi.wallet.fio.FioModule;
>>>>>>>
import com.mycelium.wapi.wallet.fio.FIOOBTransaction;
import com.mycelium.wapi.wallet.fio.FioModule;
<<<<<<<
} catch (InsufficientFundsException e) {
new Toaster(getActivity()).toast(R.string.insufficient_funds, false);
=======
} catch (InsufficientBtcException e) {
makeText(getActivity(), getResources().getString(R.string.insufficient_funds), LENGTH_LONG).show();
>>>>>>>
} catch (InsufficientBtcException e) {
new Toaster(getActivity()).toast(R.string.insufficient_funds, false); |
<<<<<<<
import com.ibm.sbt.services.client.connections.files.FileServiceException;
=======
import com.ibm.sbt.services.client.connections.forums.Forum;
import com.ibm.sbt.services.client.connections.forums.ForumService;
import com.ibm.sbt.services.client.connections.forums.ForumServiceException;
import com.ibm.sbt.services.client.connections.forums.ForumTopic;
>>>>>>>
<<<<<<<
} catch (FileServiceException e) {
throw new ClientServicesException(e);
=======
} catch (ClientServicesException e) {
throw new CommunityServiceException(e);
>>>>>>>
} catch (ClientServicesException e) {
throw new ClientServicesException(e);
<<<<<<<
} catch (FileServiceException e) {
throw new ClientServicesException(e, Messages.DownloadCommunitiesException);
=======
} catch (ClientServicesException e) {
throw new CommunityServiceException(e, Messages.DownloadCommunitiesException);
>>>>>>>
} catch (ClientServicesException e) {
throw new ClientServicesException(e, Messages.DownloadCommunitiesException);
<<<<<<<
} catch (FileServiceException e) {
throw new ClientServicesException(e, Messages.UploadCommunitiesException);
}
}
//------------------------------------------------------------------------------------------------------------------
// Internal implementations
//------------------------------------------------------------------------------------------------------------------
/***************************************************************
* Factory methods
****************************************************************/
protected Community getCommunityEntity(String requestUrl, Map<String, String> parameters) throws ClientServicesException {
try {
return getEntity(requestUrl, getParameters(parameters), getCommunityFeedHandler());
} catch (IOException e) {
throw new ClientServicesException(e);
}
}
protected Member getMemberEntity(String requestUrl, Map<String, String> parameters) throws ClientServicesException {
try {
return getEntity(requestUrl, getParameters(parameters), getMemberFeedHandler());
} catch (IOException e) {
throw new ClientServicesException(e);
}
}
protected Invite getInviteEntity(String requestUrl, Map<String, String> parameters) throws ClientServicesException {
try {
return getEntity(requestUrl, getParameters(parameters), getInviteFeedHandler());
} catch (IOException e) {
throw new ClientServicesException(e);
}
}
protected EntityList<Community> getCommunityEntityList(String requestUrl, Map<String, String> parameters) throws ClientServicesException {
try {
return getEntities(requestUrl, getParameters(parameters), getCommunityFeedHandler());
} catch (IOException e) {
throw new ClientServicesException(e);
=======
} catch (ClientServicesException e) {
throw new CommunityServiceException(e, Messages.UploadCommunitiesException);
>>>>>>>
} catch (ClientServicesException e) {
throw new ClientServicesException(e, Messages.UploadCommunitiesException);
}
}
//------------------------------------------------------------------------------------------------------------------
// Internal implementations
//------------------------------------------------------------------------------------------------------------------
/***************************************************************
* Factory methods
****************************************************************/
protected Community getCommunityEntity(String requestUrl, Map<String, String> parameters) throws ClientServicesException {
try {
return getEntity(requestUrl, getParameters(parameters), getCommunityFeedHandler());
} catch (IOException e) {
throw new ClientServicesException(e);
}
}
protected Member getMemberEntity(String requestUrl, Map<String, String> parameters) throws ClientServicesException {
try {
return getEntity(requestUrl, getParameters(parameters), getMemberFeedHandler());
} catch (IOException e) {
throw new ClientServicesException(e);
}
}
protected Invite getInviteEntity(String requestUrl, Map<String, String> parameters) throws ClientServicesException {
try {
return getEntity(requestUrl, getParameters(parameters), getInviteFeedHandler());
} catch (IOException e) {
throw new ClientServicesException(e);
}
}
protected EntityList<Community> getCommunityEntityList(String requestUrl, Map<String, String> parameters) throws ClientServicesException {
try {
return getEntities(requestUrl, getParameters(parameters), getCommunityFeedHandler());
} catch (IOException e) {
throw new ClientServicesException(e); |
<<<<<<<
import com.ibm.sbt.services.client.connections.files.FileServiceException;
=======
import com.ibm.sbt.services.client.connections.forums.Forum;
import com.ibm.sbt.services.client.connections.forums.ForumService;
import com.ibm.sbt.services.client.connections.forums.ForumServiceException;
import com.ibm.sbt.services.client.connections.forums.ForumTopic;
>>>>>>>
<<<<<<<
} catch (FileServiceException e) {
throw new ClientServicesException(e);
=======
} catch (ClientServicesException e) {
throw new CommunityServiceException(e);
>>>>>>>
} catch (ClientServicesException e) {
throw new ClientServicesException(e);
<<<<<<<
} catch (FileServiceException e) {
throw new ClientServicesException(e, Messages.DownloadCommunitiesException);
=======
} catch (ClientServicesException e) {
throw new CommunityServiceException(e, Messages.DownloadCommunitiesException);
>>>>>>>
} catch (ClientServicesException e) {
throw new ClientServicesException(e, Messages.DownloadCommunitiesException);
<<<<<<<
} catch (FileServiceException e) {
throw new ClientServicesException(e, Messages.UploadCommunitiesException);
}
}
//------------------------------------------------------------------------------------------------------------------
// Internal implementations
//------------------------------------------------------------------------------------------------------------------
/***************************************************************
* Factory methods
****************************************************************/
protected Community getCommunityEntity(String requestUrl, Map<String, String> parameters) throws ClientServicesException {
try {
return getEntity(requestUrl, getParameters(parameters), getCommunityFeedHandler());
} catch (IOException e) {
throw new ClientServicesException(e);
}
}
protected Member getMemberEntity(String requestUrl, Map<String, String> parameters) throws ClientServicesException {
try {
return getEntity(requestUrl, getParameters(parameters), getMemberFeedHandler());
} catch (IOException e) {
throw new ClientServicesException(e);
}
}
protected Invite getInviteEntity(String requestUrl, Map<String, String> parameters) throws ClientServicesException {
try {
return getEntity(requestUrl, getParameters(parameters), getInviteFeedHandler());
} catch (IOException e) {
throw new ClientServicesException(e);
}
}
protected EntityList<Community> getCommunityEntityList(String requestUrl, Map<String, String> parameters) throws ClientServicesException {
try {
return getEntities(requestUrl, getParameters(parameters), getCommunityFeedHandler());
} catch (IOException e) {
throw new ClientServicesException(e);
=======
} catch (ClientServicesException e) {
throw new CommunityServiceException(e, Messages.UploadCommunitiesException);
>>>>>>>
} catch (ClientServicesException e) {
throw new ClientServicesException(e, Messages.UploadCommunitiesException);
}
}
//------------------------------------------------------------------------------------------------------------------
// Internal implementations
//------------------------------------------------------------------------------------------------------------------
/***************************************************************
* Factory methods
****************************************************************/
protected Community getCommunityEntity(String requestUrl, Map<String, String> parameters) throws ClientServicesException {
try {
return getEntity(requestUrl, getParameters(parameters), getCommunityFeedHandler());
} catch (IOException e) {
throw new ClientServicesException(e);
}
}
protected Member getMemberEntity(String requestUrl, Map<String, String> parameters) throws ClientServicesException {
try {
return getEntity(requestUrl, getParameters(parameters), getMemberFeedHandler());
} catch (IOException e) {
throw new ClientServicesException(e);
}
}
protected Invite getInviteEntity(String requestUrl, Map<String, String> parameters) throws ClientServicesException {
try {
return getEntity(requestUrl, getParameters(parameters), getInviteFeedHandler());
} catch (IOException e) {
throw new ClientServicesException(e);
}
}
protected EntityList<Community> getCommunityEntityList(String requestUrl, Map<String, String> parameters) throws ClientServicesException {
try {
return getEntities(requestUrl, getParameters(parameters), getCommunityFeedHandler());
} catch (IOException e) {
throw new ClientServicesException(e); |
<<<<<<<
activity.setData(node, nameSpaceCtx, xpath);
=======
activity.setData(node, ConnectionsConstants.nameSpaceCtx, xpath);
activity.setService(this);
>>>>>>>
activity.setData(node, nameSpaceCtx, xpath);
activity.setService(this);
<<<<<<<
activityNode.setData(node, nameSpaceCtx, xpath);
=======
activityNode.setData(node, ConnectionsConstants.nameSpaceCtx, xpath);
activityNode.setService(this);
>>>>>>>
activityNode.setData(node, nameSpaceCtx, xpath);
activityNode.setService(this);
<<<<<<<
member.setData(node, nameSpaceCtx, xpath);
=======
member.setData(node, ConnectionsConstants.nameSpaceCtx, xpath);
member.setService(this);
>>>>>>>
member.setData(node, nameSpaceCtx, xpath);
member.setService(this); |
<<<<<<<
activity.setData(node, nameSpaceCtx, xpath);
=======
activity.setData(node, ConnectionsConstants.nameSpaceCtx, xpath);
activity.setService(this);
>>>>>>>
activity.setData(node, nameSpaceCtx, xpath);
activity.setService(this);
<<<<<<<
activityNode.setData(node, nameSpaceCtx, xpath);
=======
activityNode.setData(node, ConnectionsConstants.nameSpaceCtx, xpath);
activityNode.setService(this);
>>>>>>>
activityNode.setData(node, nameSpaceCtx, xpath);
activityNode.setService(this);
<<<<<<<
member.setData(node, nameSpaceCtx, xpath);
=======
member.setData(node, ConnectionsConstants.nameSpaceCtx, xpath);
member.setService(this);
>>>>>>>
member.setData(node, nameSpaceCtx, xpath);
member.setService(this); |
<<<<<<<
return textElement(PUBLISHED, DateSerializer.toString(entity.getPublished()));
=======
return textElement("published", DateSerializer.toString(dateFormat, entity.getPublished()));
>>>>>>>
return textElement(PUBLISHED, DateSerializer.toString(dateFormat, entity.getPublished()));
<<<<<<<
return textElement(UPDATED, DateSerializer.toString(entity.getUpdated()));
=======
return textElement("updated", DateSerializer.toString(dateFormat, entity.getUpdated()));
>>>>>>>
return textElement(UPDATED, DateSerializer.toString(dateFormat, entity.getUpdated())); |
<<<<<<<
import java.util.Date;
=======
import java.util.Date;
>>>>>>>
import java.util.Date;
<<<<<<<
@Test
public void testMoveNodeACL() throws ClientServicesException {
Activity activityA = new Activity();
activityA.setTitle(createActivityTitle());
activityA = activityService.createActivity(activityA);
Activity activityB = new Activity();
activityB.setTitle(createActivityTitle());
activityB = activityService.createActivity(activityB);
String memberId = getMemberId();
Member member = activityB.addMember("person", memberId, "owner");
ActivityNode srcActivityNode = new ActivityNode();
srcActivityNode.setActivityUuid(activityA.getActivityUuid());
srcActivityNode.setTitle("Source ActivityNode");
srcActivityNode.setType("ENTRY");
// Field 1
TextField textField = new TextField();
textField.setName("test_text");
textField.setPosition(1000);
textField.setSummary("Test_Text_Field");
// Field 2
Date date = new Date();
date.setTime(1397650699000L);
DateField dateField = new DateField();
dateField.setName("test_date");
dateField.setPosition(2000);
dateField.setDate(date);
// Field 3
TextField hiddenTextField = new TextField();
hiddenTextField.setName("test_hidden_text");
hiddenTextField.setPosition(3000);
hiddenTextField.setSummary("Hidden_Text_Field");
hiddenTextField.setHidden(true);
srcActivityNode.addField(textField);
srcActivityNode.addField(hiddenTextField);
srcActivityNode.addField(dateField);
srcActivityNode = activityService.createActivityNode(srcActivityNode);
int numFields = srcActivityNode.getFields().length;
activityService.moveNode(srcActivityNode.getActivityNodeUuid(), activityB.getActivityUuid());
BasicEndpoint endpoint = (BasicEndpoint)activityService.getEndpoint();
try {
endpoint.logout();
endpoint.login(TestEnvironment.getSecondaryUserEmail(), TestEnvironment.getSecondaryUserPassword());
} catch (AuthenticationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
ActivityNode read = activityService.getActivityNode(srcActivityNode.getActivityNodeUuid());
assertNotNull(read);
Field movedTextField = read.getFieldByName(textField.getName());
assertTrue(movedTextField instanceof TextField);
assertEquals("test_text", movedTextField.getName());
assertEquals(1000, ((TextField)movedTextField).getPosition());
assertEquals("Test_Text_Field", ((TextField)movedTextField).getSummary());
// Check date field
Field movedDateField = read.getFieldByName(dateField.getName());
assertTrue(movedDateField instanceof DateField);
assertEquals("test_date", ((DateField)movedDateField).getName());
assertEquals(2000, ((DateField)movedDateField).getPosition());
assertNotNull(((DateField)movedDateField).getDate());
// Check hidden text field
Field movedHiddenTextField = read.getFieldByName(hiddenTextField.getName());
assertTrue(movedHiddenTextField instanceof TextField);
assertTrue(((TextField)movedHiddenTextField).isHidden());
assertEquals("test_hidden_text", ((TextField)movedHiddenTextField).getName());
assertEquals(3000, ((TextField)movedHiddenTextField).getPosition());
assertEquals("Hidden_Text_Field", ((TextField)movedHiddenTextField).getSummary());
}
=======
@Test
public void testNotFound() throws ClientServicesException, XMLException {
// Create activity nodes
activity = new Activity();
activity.setTitle(createActivityTitle());
activity = activityService.createActivity(activity);
try {
activityService.moveNode("1234", activity.getActivityUuid());
} catch (ClientServicesException ex) {
assertEquals(404, ex.getResponseStatusCode());
return;
}
fail();
}
@Test
public void testNotAuthorized() throws ClientServicesException, XMLException, AuthenticationException {
// Create activity nodes
activity = new Activity();
activity.setTitle(createActivityTitle());
activity = activityService.createActivity(activity);
ActivityNode entryNode = new ActivityNode();
entryNode.setActivityUuid(activity.getActivityUuid());
entryNode.setTitle("Source ActivityNode");
entryNode.setType("ENTRY");
activityService.createActivityNode(entryNode);
activityService.getEndpoint().logout();
((BasicEndpoint) activityService.getEndpoint()).login(TestEnvironment.getSecondaryUsername(),
TestEnvironment.getSecondaryUserPassword());
try {
activityService.moveNode(entryNode.getActivityNodeUuid(), activity.getActivityUuid());
} catch (ClientServicesException ex) {
assertEquals(403, ex.getResponseStatusCode());
return;
} finally {
activityService.getEndpoint().logout();
((BasicEndpoint) activityService.getEndpoint()).login(TestEnvironment.getCurrentUsername(),
TestEnvironment.getCurrentUserPassword());
}
fail();
}
>>>>>>>
@Test
public void testNotFound() throws ClientServicesException, XMLException {
// Create activity nodes
activity = new Activity();
activity.setTitle(createActivityTitle());
activity = activityService.createActivity(activity);
try {
activityService.moveNode("1234", activity.getActivityUuid());
} catch (ClientServicesException ex) {
assertEquals(404, ex.getResponseStatusCode());
return;
}
fail();
}
@Test
public void testNotAuthorized() throws ClientServicesException, XMLException, AuthenticationException {
// Create activity nodes
activity = new Activity();
activity.setTitle(createActivityTitle());
activity = activityService.createActivity(activity);
ActivityNode entryNode = new ActivityNode();
entryNode.setActivityUuid(activity.getActivityUuid());
entryNode.setTitle("Source ActivityNode");
entryNode.setType("ENTRY");
activityService.createActivityNode(entryNode);
activityService.getEndpoint().logout();
((BasicEndpoint) activityService.getEndpoint()).login(TestEnvironment.getSecondaryUsername(),
TestEnvironment.getSecondaryUserPassword());
try {
activityService.moveNode(entryNode.getActivityNodeUuid(), activity.getActivityUuid());
} catch (ClientServicesException ex) {
assertEquals(403, ex.getResponseStatusCode());
return;
} finally {
activityService.getEndpoint().logout();
((BasicEndpoint) activityService.getEndpoint()).login(TestEnvironment.getCurrentUsername(),
TestEnvironment.getCurrentUserPassword());
}
fail();
}
@Test
public void testMoveNodeACL() throws ClientServicesException {
Activity activityA = new Activity();
activityA.setTitle(createActivityTitle());
activityA = activityService.createActivity(activityA);
Activity activityB = new Activity();
activityB.setTitle(createActivityTitle());
activityB = activityService.createActivity(activityB);
String memberId = getMemberId();
Member member = activityB.addMember("person", memberId, "owner");
ActivityNode srcActivityNode = new ActivityNode();
srcActivityNode.setActivityUuid(activityA.getActivityUuid());
srcActivityNode.setTitle("Source ActivityNode");
srcActivityNode.setType("ENTRY");
// Field 1
TextField textField = new TextField();
textField.setName("test_text");
textField.setPosition(1000);
textField.setSummary("Test_Text_Field");
// Field 2
Date date = new Date();
date.setTime(1397650699000L);
DateField dateField = new DateField();
dateField.setName("test_date");
dateField.setPosition(2000);
dateField.setDate(date);
// Field 3
TextField hiddenTextField = new TextField();
hiddenTextField.setName("test_hidden_text");
hiddenTextField.setPosition(3000);
hiddenTextField.setSummary("Hidden_Text_Field");
hiddenTextField.setHidden(true);
srcActivityNode.addField(textField);
srcActivityNode.addField(hiddenTextField);
srcActivityNode.addField(dateField);
srcActivityNode = activityService.createActivityNode(srcActivityNode);
int numFields = srcActivityNode.getFields().length;
activityService.moveNode(srcActivityNode.getActivityNodeUuid(), activityB.getActivityUuid());
BasicEndpoint endpoint = (BasicEndpoint)activityService.getEndpoint();
try {
endpoint.logout();
endpoint.login(TestEnvironment.getSecondaryUserEmail(), TestEnvironment.getSecondaryUserPassword());
} catch (AuthenticationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
ActivityNode read = activityService.getActivityNode(srcActivityNode.getActivityNodeUuid());
assertNotNull(read);
Field movedTextField = read.getFieldByName(textField.getName());
assertTrue(movedTextField instanceof TextField);
assertEquals("test_text", movedTextField.getName());
assertEquals(1000, ((TextField)movedTextField).getPosition());
assertEquals("Test_Text_Field", ((TextField)movedTextField).getSummary());
// Check date field
Field movedDateField = read.getFieldByName(dateField.getName());
assertTrue(movedDateField instanceof DateField);
assertEquals("test_date", ((DateField)movedDateField).getName());
assertEquals(2000, ((DateField)movedDateField).getPosition());
assertNotNull(((DateField)movedDateField).getDate());
// Check hidden text field
Field movedHiddenTextField = read.getFieldByName(hiddenTextField.getName());
assertTrue(movedHiddenTextField instanceof TextField);
assertTrue(((TextField)movedHiddenTextField).isHidden());
assertEquals("test_hidden_text", ((TextField)movedHiddenTextField).getName());
assertEquals(3000, ((TextField)movedHiddenTextField).getPosition());
assertEquals("Hidden_Text_Field", ((TextField)movedHiddenTextField).getSummary());
} |
<<<<<<<
report_an_issue_view.findViewById(R.id.button1).setOnClickListener(reportIssueClickListener);
mExpandableListView.addFooterView(report_an_issue_view);
=======
report_an_issue_view.findViewById(R.id.button1)
.setOnClickListener(reportIssueClickListener);
mExpandableListView.addFooterView(report_an_issue_view);
>>>>>>>
report_an_issue_view.findViewById(R.id.button1).setOnClickListener(reportIssueClickListener);
report_an_issue_view.findViewById(R.id.button1)
.setOnClickListener(reportIssueClickListener);
mExpandableListView.addFooterView(report_an_issue_view);
<<<<<<<
// Button reportIssueButton = (Button)rootView.findViewById(R.id.reportIssueButton);
// reportIssueButton.setOnClickListener(new OnClickListener() {
//
// @Override
// public void onClick(View v) {
// if(isNewUser) {
// HSActivityManager.startNewUserActivity(getActivity());
// }else {
// HSActivityManager.startNewIssueActivity(getActivity());
// }
// }
// });
=======
>>>>>>>
<<<<<<<
Log.v("Helpstack","Report an issue");
=======
if(gearSource.isNewUser()) {
HSActivityManager.startNewUserActivity(getActivity());
}else {
HSActivityManager.startNewIssueActivity(getActivity());
}
>>>>>>>
Log.v("Helpstack","Report an issue"); |
<<<<<<<
private SearchAdapter searchAdapter;
=======
private HSKBItem[] searchableKBArticle;
>>>>>>>
private SearchAdapter searchAdapter;
private HSKBItem[] searchableKBArticle; |
<<<<<<<
if (ProtocolRegistry.isSupported(ConnectionInfo.protocolVersion)) {
((HandshakePacketAccessor) packet).setProtocolVersion(ConnectionInfo.protocolVersion);
=======
if (ConnectionMode.isSupportedProtocol(ConnectionInfo.protocolVersion)) {
((HandshakePacketAccessor) packet).setVersion(ConnectionInfo.protocolVersion);
>>>>>>>
if (ConnectionMode.isSupportedProtocol(ConnectionInfo.protocolVersion)) {
((HandshakePacketAccessor) packet).setProtocolVersion(ConnectionInfo.protocolVersion); |
<<<<<<<
import net.earthcomputer.multiconnect.protocols.generic.IChunkDataS2CPacket;
=======
import net.earthcomputer.multiconnect.impl.Utils;
import net.earthcomputer.multiconnect.transformer.ChunkData;
import net.earthcomputer.multiconnect.transformer.TransformerByteBuf;
import net.minecraft.datafixer.TypeReferences;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.network.PacketByteBuf;
>>>>>>>
import net.earthcomputer.multiconnect.protocols.generic.IChunkDataS2CPacket;
import net.earthcomputer.multiconnect.impl.Utils;
import net.minecraft.datafixer.TypeReferences;
import net.minecraft.nbt.CompoundTag;
<<<<<<<
import org.spongepowered.asm.mixin.Unique;
import org.spongepowered.asm.mixin.gen.Accessor;
=======
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
>>>>>>>
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.Unique;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
import org.spongepowered.asm.mixin.gen.Accessor; |
<<<<<<<
if (options.renamePrefixNamespace != null) {
if (!GLOBAL_SYMBOL_NAMESPACE_PATTERN.matcher(options.renamePrefixNamespace).matches()) {
=======
if (options.renamePrefixNamespace != null &&
options.chunkOutputType == ChunkOutputType.GLOBAL_NAMESPACE) {
if (!GLOBAL_SYMBOL_NAMESPACE_PATTERN.matcher(
options.renamePrefixNamespace).matches()) {
>>>>>>>
if (options.renamePrefixNamespace != null
&& options.chunkOutputType == ChunkOutputType.GLOBAL_NAMESPACE) {
if (!GLOBAL_SYMBOL_NAMESPACE_PATTERN.matcher(options.renamePrefixNamespace).matches()) { |
<<<<<<<
/**
*
* @return the fromDocId
*/
public Integer getFromDocId() {
return fromDocId;
}
/**
* @param id of the document from which the cross navigation starts
*/
public void setFromDocId(Integer fromDocId) {
this.fromDocId = fromDocId;
}
/**
*
* @return the toDocId
*/
public Integer getToDocId() {
return toDocId;
}
/**
* @param id of the document in which the cross navigation ends
*/
public void setToDocId(Integer toDocId) {
this.toDocId = toDocId;
}
=======
public String getPopupOptions() {
return popupOptions;
}
public void setPopupOptions(String popupOptions) {
this.popupOptions = popupOptions;
}
>>>>>>>
/**
*
* @return the fromDocId
*/
public Integer getFromDocId() {
return fromDocId;
}
/**
* @param id of the document from which the cross navigation starts
*/
public void setFromDocId(Integer fromDocId) {
this.fromDocId = fromDocId;
}
/**
*
* @return the toDocId
*/
public Integer getToDocId() {
return toDocId;
}
/**
* @param id of the document in which the cross navigation ends
*/
public void setToDocId(Integer toDocId) {
this.toDocId = toDocId;
}
public String getPopupOptions() {
return popupOptions;
}
public void setPopupOptions(String popupOptions) {
this.popupOptions = popupOptions;
} |
<<<<<<<
import com.mycelium.wapi.content.eth.EthUriParser;
import com.mycelium.wapi.wallet.*;
import com.mycelium.wapi.wallet.btc.*;
import com.mycelium.wapi.wallet.btc.bip44.*;
import com.mycelium.wapi.wallet.btc.single.*;
=======
import com.mycelium.wapi.wallet.AccountListener;
import com.mycelium.wapi.wallet.AesKeyCipher;
import com.mycelium.wapi.wallet.CurrencySettings;
import com.mycelium.wapi.wallet.GenericAddress;
import com.mycelium.wapi.wallet.IdentityAccountKeyManager;
import com.mycelium.wapi.wallet.KeyCipher;
import com.mycelium.wapi.wallet.SecureKeyValueStore;
import com.mycelium.wapi.wallet.SyncMode;
import com.mycelium.wapi.wallet.WalletAccount;
import com.mycelium.wapi.wallet.WalletManager;
import com.mycelium.wapi.wallet.btc.AbstractBtcAccount;
import com.mycelium.wapi.wallet.btc.BTCSettings;
import com.mycelium.wapi.wallet.btc.BtcAddress;
import com.mycelium.wapi.wallet.btc.BtcWalletManagerBacking;
import com.mycelium.wapi.wallet.btc.ChangeAddressMode;
import com.mycelium.wapi.wallet.btc.InMemoryBtcWalletManagerBacking;
import com.mycelium.wapi.wallet.btc.Reference;
import com.mycelium.wapi.wallet.btc.bip44.AdditionalHDAccountConfig;
import com.mycelium.wapi.wallet.btc.bip44.BitcoinHDModule;
import com.mycelium.wapi.wallet.btc.bip44.ExternalSignatureProviderProxy;
import com.mycelium.wapi.wallet.btc.bip44.HDAccount;
import com.mycelium.wapi.wallet.btc.bip44.HDAccountContext;
import com.mycelium.wapi.wallet.btc.single.AddressSingleConfig;
import com.mycelium.wapi.wallet.btc.single.BitcoinSingleAddressModule;
import com.mycelium.wapi.wallet.btc.single.PrivateSingleConfig;
import com.mycelium.wapi.wallet.btc.single.PublicPrivateKeyStore;
import com.mycelium.wapi.wallet.btc.single.PublicSingleConfig;
import com.mycelium.wapi.wallet.btc.single.SingleAddressAccount;
>>>>>>>
import com.mycelium.wapi.content.eth.EthUriParser;
import com.mycelium.wapi.wallet.AccountListener;
import com.mycelium.wapi.wallet.AesKeyCipher;
import com.mycelium.wapi.wallet.CurrencySettings;
import com.mycelium.wapi.wallet.GenericAddress;
import com.mycelium.wapi.wallet.IdentityAccountKeyManager;
import com.mycelium.wapi.wallet.KeyCipher;
import com.mycelium.wapi.wallet.SecureKeyValueStore;
import com.mycelium.wapi.wallet.SyncMode;
import com.mycelium.wapi.wallet.WalletAccount;
import com.mycelium.wapi.wallet.WalletManager;
import com.mycelium.wapi.wallet.btc.AbstractBtcAccount;
import com.mycelium.wapi.wallet.btc.BTCSettings;
import com.mycelium.wapi.wallet.btc.BtcAddress;
import com.mycelium.wapi.wallet.btc.BtcWalletManagerBacking;
import com.mycelium.wapi.wallet.btc.ChangeAddressMode;
import com.mycelium.wapi.wallet.btc.InMemoryBtcWalletManagerBacking;
import com.mycelium.wapi.wallet.btc.Reference;
import com.mycelium.wapi.wallet.btc.bip44.AdditionalHDAccountConfig;
import com.mycelium.wapi.wallet.btc.bip44.BitcoinHDModule;
import com.mycelium.wapi.wallet.btc.bip44.ExternalSignatureProviderProxy;
import com.mycelium.wapi.wallet.btc.bip44.HDAccount;
import com.mycelium.wapi.wallet.btc.bip44.HDAccountContext;
import com.mycelium.wapi.wallet.btc.single.AddressSingleConfig;
import com.mycelium.wapi.wallet.btc.single.BitcoinSingleAddressModule;
import com.mycelium.wapi.wallet.btc.single.PrivateSingleConfig;
import com.mycelium.wapi.wallet.btc.single.PublicPrivateKeyStore;
import com.mycelium.wapi.wallet.btc.single.PublicSingleConfig;
import com.mycelium.wapi.wallet.btc.single.SingleAddressAccount;
<<<<<<<
import com.squareup.sqldelight.android.AndroidSqliteDriver;
import com.squareup.sqldelight.db.SqlDriver;
import kotlin.jvm.Synchronized;
=======
>>>>>>>
import com.squareup.sqldelight.android.AndroidSqliteDriver;
import com.squareup.sqldelight.db.SqlDriver;
import kotlin.jvm.Synchronized;
<<<<<<<
AccountContextsBacking genericBacking = new AccountContextsBacking(db);
EthBacking ethBacking = new EthBacking(db, genericBacking);
walletManager.add(new EthereumModule(secureKeyValueStore, ethBacking, walletDB, getMetadataStorage(), accountListener));
=======
>>>>>>>
AccountContextsBacking genericBacking = new AccountContextsBacking(db);
EthBacking ethBacking = new EthBacking(db, genericBacking);
walletManager.add(new EthereumModule(secureKeyValueStore, ethBacking, walletDB, getMetadataStorage(), accountListener));
<<<<<<<
public GenericAssetInfo getFiatCurrency(GenericAssetInfo coinType) {
return _currencySwitcher.getCurrentFiatCurrency(coinType);
=======
public boolean isAppInForeground() {
return appInForeground;
}
public void setAppInForeground(boolean appInForeground) {
getWapi().setAppInForeground(appInForeground);
this.appInForeground = appInForeground;
}
public GenericAssetInfo getFiatCurrency() {
return _currencySwitcher.getCurrentFiatCurrency();
>>>>>>>
public GenericAssetInfo getFiatCurrency(GenericAssetInfo coinType) {
return _currencySwitcher.getCurrentFiatCurrency(coinType);
}
public boolean isAppInForeground() {
return appInForeground;
}
public void setAppInForeground(boolean appInForeground) {
getWapi().setAppInForeground(appInForeground);
this.appInForeground = appInForeground; |
<<<<<<<
logger.debug("Dialect set is " + dialect);
if (getToolsDataSource().checkIsJndi()) {
cfg.put("javax.persistence.nonJtaDataSource", getToolsDataSource().getJndi());
=======
logger.debug("Dialect set is " + dialect);
if (dataSource.checkIsJndi()) {
IEngUserProfile profile = UserProfileManager.getProfile();
cfg.put("javax.persistence.nonJtaDataSource", dataSource.getJNDIRunTime(profile));
>>>>>>>
if (dataSource.checkIsJndi()) {
IEngUserProfile profile = UserProfileManager.getProfile();
cfg.put("javax.persistence.nonJtaDataSource", dataSource.getJNDIRunTime(profile)); |
<<<<<<<
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Time;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import org.apache.log4j.Logger;
import org.joda.time.Instant;
import org.json.JSONArray;
import org.json.JSONException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.gson.Gson;
=======
>>>>>>>
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Time;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import org.apache.log4j.Logger;
import org.joda.time.Instant;
import org.json.JSONArray;
import org.json.JSONException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper; |
<<<<<<<
import it.eng.spagobi.tools.dataset.common.query.AggregationFunctions;
import it.eng.spagobi.tools.dataset.common.query.IAggregationFunction;
import it.eng.spagobi.tools.dataset.metasql.query.item.AbstractSelectionField;
import it.eng.spagobi.tools.dataset.metasql.query.item.DataStoreCalculatedField;
=======
>>>>>>>
<<<<<<<
private Object getValue(FieldStatsInfo fieldStats, IAggregationFunction aggregationFunction) {
if (AggregationFunctions.COUNT.equals(aggregationFunction.getName())) {
return fieldStats.getCount();
}
if (AggregationFunctions.COUNT_DISTINCT.equals(aggregationFunction.getName())) {
return fieldStats.getCountDistinct();
}
if (AggregationFunctions.MIN.equals(aggregationFunction.getName())) {
return fieldStats.getMin();
}
if (AggregationFunctions.MAX.equals(aggregationFunction.getName())) {
return fieldStats.getMax();
}
if (AggregationFunctions.SUM.equals(aggregationFunction.getName())) {
return fieldStats.getSum();
}
if (AggregationFunctions.AVG.equals(aggregationFunction.getName())) {
return fieldStats.getMean();
}
throw new IllegalArgumentException("The function " + aggregationFunction.getName() + " is not valid here");
}
private Map<String, String> getFacetsWithAggregation(List<AbstractSelectionField> groups) {
=======
private Map<String, String> getFacetsWithAggregation(List<Projection> groups) {
>>>>>>>
private Map<String, String> getFacetsWithAggregation(List<AbstractSelectionField> groups) { |
<<<<<<<
import com.mycelium.wapi.wallet.WalletAccount;
=======
import com.mycelium.wallet.exchange.FiatType;
>>>>>>>
import com.mycelium.wapi.wallet.WalletAccount;
import com.mycelium.wallet.exchange.FiatType;
<<<<<<<
=======
import com.mycelium.wapi.wallet.coins.BitcoinTest;
import com.mycelium.wapi.wallet.coins.Value;
>>>>>>>
import com.mycelium.wapi.wallet.coins.BitcoinTest;
import com.mycelium.wapi.wallet.coins.Value;
<<<<<<<
if (_amount == null || _amount.getValue() == null) {
_amount = ExactCurrencyValue.from(null, _account.getCoinType().getSymbol());
=======
if (_amount == null) {
// todo get generic value (BTC/ETH) ? using _account.getAccountDefaultCurrency()
_amount = Value.valueOf(BitcoinTest.get(), 0);
>>>>>>>
if (_amount == null) {
// todo get generic value (BTC/ETH) ? using _account.getAccountDefaultCurrency()
_amount = Value.valueOf(BitcoinTest.get(), 0); |
<<<<<<<
import java.awt.Color;
=======
import com.jogamp.opengl.*;
import com.jogamp.opengl.awt.GLJPanel;
import com.marginallyclever.drawingtools.DrawingTool;
import javax.swing.event.MouseInputListener;
import java.awt.*;
>>>>>>>
import java.awt.Color;
import com.jogamp.opengl.*;
import com.jogamp.opengl.awt.GLJPanel;
import com.marginallyclever.drawingtools.DrawingTool;
import javax.swing.event.MouseInputListener;
import java.awt.*;
<<<<<<<
/**
* scale the picture of the robot to fake a zoom.
*/
public void zoomToFitPaper() {
int drawPanelWidth = this.getWidth();
int drawPanelHeight = this.getHeight();
double widthOfPaper = machine.paper_right - machine.paper_left;
double heightOfPaper = machine.paper_top - machine.paper_bottom;
double drawPanelWidthZoom = drawPanelWidth / widthOfPaper;
double drawPanelHeightZoom = drawPanelHeight / heightOfPaper;
cameraZoom = (drawPanelWidthZoom < drawPanelHeightZoom ? drawPanelWidthZoom : drawPanelHeightZoom );
cameraOffsetX = 0;
cameraOffsetY = 0;
repaint();
}
public void mousePressed(MouseEvent e) {
buttonPressed=e.getButton();
oldx=e.getX();
oldy=e.getY();
}
public void mouseReleased(MouseEvent e) {
buttonPressed=MouseEvent.NOBUTTON;
}
public void mouseClicked(MouseEvent e) {}
public void mouseEntered(MouseEvent e) {}
public void mouseExited(MouseEvent e) {}
public void mouseDragged(MouseEvent e) {
int x=e.getX();
int y=e.getY();
if(buttonPressed==MouseEvent.BUTTON1) {
moveCamera(x,y);
} else if(buttonPressed==MouseEvent.BUTTON3) {
zoomCamera(y);
}
gondola_x=x-window_width/2;
gondola_y=y-window_height/2;
oldx=x;
oldy=y;
repaint();
}
public void mouseMoved(MouseEvent e) {
int x=e.getX();
int y=e.getY();
gondola_x=x-window_width/2;
gondola_y=y-window_height/2;
repaint();
}
/**
* set up the correct modelview so the robot appears where it hsould.
* @param gl2
*/
private void paintCamera(GL2 gl2) {
gl2.glMatrixMode(GL2.GL_MODELVIEW);
gl2.glLoadIdentity();
gl2.glScaled(cameraZoom, cameraZoom, 1.0d);
gl2.glTranslated(-cameraOffsetX, cameraOffsetY,0);
=======
// draw the world
render(gl2);
}
public void setGCode(GCodeFile gcode) {
instructions = gcode;
emptyNodeBuffer();
// process the image into a buffer once rather than re-reading the gcode over and over again?
repaint();
}
public void emptyNodeBuffer() {
fast_nodes.clear();
optimizeNodes();
}
public void updateMachineConfig() {
repaint();
}
/**
* toggle pen up moves.
*
* @param state if <strong>true</strong> the pen up moves will be drawn. if <strong>false</strong> they will be hidden.
*/
public void setShowPenUp(boolean state) {
show_pen_up = state;
instructions.changed = true;
repaint();
}
/**
* @return the "show pen up" flag
*/
public boolean getShowPenUp() {
return show_pen_up;
}
public void setLinesProcessed(long c) {
linesProcessed = c;
if ((linesProcessed % 10) == 0) repaint();
}
public void setConnected(boolean state) {
connected = state;
repaint();
}
public void setRunning(boolean state) {
running = state;
if (running == false) {
linesProcessed = 0;
>>>>>>>
// draw the world
render(gl2);
}
/**
* scale the picture of the robot to fake a zoom.
*/
public void zoomToFitPaper() {
int drawPanelWidth = this.getWidth();
int drawPanelHeight = this.getHeight();
double widthOfPaper = machine.paper_right - machine.paper_left;
double heightOfPaper = machine.paper_top - machine.paper_bottom;
double drawPanelWidthZoom = drawPanelWidth / widthOfPaper;
double drawPanelHeightZoom = drawPanelHeight / heightOfPaper;
cameraZoom = (drawPanelWidthZoom < drawPanelHeightZoom ? drawPanelWidthZoom : drawPanelHeightZoom );
cameraOffsetX = 0;
cameraOffsetY = 0;
repaint();
}
public void mousePressed(MouseEvent e) {
buttonPressed=e.getButton();
oldx=e.getX();
oldy=e.getY();
}
public void mouseReleased(MouseEvent e) {
buttonPressed=MouseEvent.NOBUTTON;
}
public void mouseClicked(MouseEvent e) {}
public void mouseEntered(MouseEvent e) {}
public void mouseExited(MouseEvent e) {}
public void mouseDragged(MouseEvent e) {
int x=e.getX();
int y=e.getY();
if(buttonPressed==MouseEvent.BUTTON1) {
moveCamera(x,y);
} else if(buttonPressed==MouseEvent.BUTTON3) {
zoomCamera(y);
}
gondola_x=x-window_width/2;
gondola_y=y-window_height/2;
oldx=x;
oldy=y;
repaint();
}
public void mouseMoved(MouseEvent e) {
int x=e.getX();
int y=e.getY();
gondola_x=x-window_width/2;
gondola_y=y-window_height/2;
repaint();
}
public void setGCode(GCodeFile gcode) {
instructions = gcode;
emptyNodeBuffer();
// process the image into a buffer once rather than re-reading the gcode over and over again?
repaint();
}
public void emptyNodeBuffer() {
fast_nodes.clear();
optimizeNodes();
}
public void updateMachineConfig() {
repaint();
}
/**
* toggle pen up moves.
*
* @param state if <strong>true</strong> the pen up moves will be drawn. if <strong>false</strong> they will be hidden.
*/
public void setShowPenUp(boolean state) {
show_pen_up = state;
instructions.changed = true;
repaint();
}
/**
* @return the "show pen up" flag
*/
public boolean getShowPenUp() {
return show_pen_up;
}
public void setLinesProcessed(long c) {
linesProcessed = c;
if ((linesProcessed % 10) == 0) repaint();
}
public void setConnected(boolean state) {
connected = state;
repaint();
}
public void setRunning(boolean state) {
running = state;
if (running == false) {
linesProcessed = 0;
<<<<<<<
paintMotors(gl2);
// TODO draw control box?
if(drawDecorator!=null) {
// filters can also draw WYSIWYG previews while converting.
drawDecorator.render(gl2,machine);
=======
if (drawDecorator != null) {
drawDecorator.render(gl2, machine);
>>>>>>>
paintMotors(gl2);
paintGondolaAndCounterweights(gl2);
// TODO draw control box?
if(drawDecorator!=null) {
// filters can also draw WYSIWYG previews while converting.
drawDecorator.render(gl2,machine);
<<<<<<<
paintGcode(gl2);
paintGondola(gl2);
}
private void paintGcode( GL2 gl2 ) {
// TODO move all robot drawing to a class
=======
// TODO draw left motor, right motor, and control box
// TODO move all robot drawing to a class so that filters can also draw WYSIWYG previews while converting.
>>>>>>>
paintGcode(gl2);
}
private void paintGcode( GL2 gl2 ) {
// TODO move all robot drawing to a class
<<<<<<<
gl2.glColor3f(0, 0, 0);
// draw image
if(fast_nodes.size()>0) {
// draw the nodes
Iterator<DrawPanelNode> nodes = fast_nodes.iterator();
while(nodes.hasNext()) {
DrawPanelNode n=nodes.next();
if(running) {
if(n.line_number<=linesProcessed) {
gl2.glColor3f(1, 0, 0);
//g2d.setColor(Color.RED);
} else if(n.line_number<=linesProcessed+look_ahead) {
if( n.line_number == linesProcessed+look_ahead ) {
gondola_x=n.x1;
gondola_y=n.y1;
}
gl2.glColor3f(0, 1, 0);
//g2d.setColor(Color.GREEN);
} else if(prefs.getBoolean("Draw all while running", true) == false) {
break;
}
}
switch(n.type) {
case TOOL:
tool = machine.getTool(n.tool_id);
gl2.glLineWidth(tool.getDiameter()*(float)this.cameraZoom/10.0f);
break;
case COLOR:
if(!running || n.line_number>linesProcessed+look_ahead) {
//g2d.setColor(n.c);
gl2.glColor3f(n.c.getRed()/255.0f,n.c.getGreen()/255.0f,n.c.getBlue()/255.0f);
}
break;
default:
tool.drawLine(gl2, n.x1, n.y1, n.x2, n.y2);
break;
}
=======
gl2.glColor3f(0, 0, 0);
// draw image
if (fast_nodes.size() > 0) {
// draw the nodes
Iterator<DrawPanelNode> nodes = fast_nodes.iterator();
while (nodes.hasNext()) {
DrawPanelNode n = nodes.next();
if (running) {
if (n.line_number <= linesProcessed) {
gl2.glColor3f(1, 0, 0);
//g2d.setColor(Color.RED);
} else if (n.line_number <= linesProcessed + look_ahead) {
gl2.glColor3f(0, 1, 0);
//g2d.setColor(Color.GREEN);
} else if (prefs.getBoolean("Draw all while running", true) == false) {
break;
}
}
switch (n.type) {
case TOOL:
tool = machine.getTool(n.tool_id);
gl2.glLineWidth(tool.getDiameter() * (float) this.cameraZoom / 10.0f);
break;
case COLOR:
if (!running || n.line_number > linesProcessed + look_ahead) {
//g2d.setColor(n.c);
gl2.glColor3f(n.c.getRed() / 255.0f, n.c.getGreen() / 255.0f, n.c.getBlue() / 255.0f);
>>>>>>>
gl2.glColor3f(0, 0, 0);
// draw image
if (fast_nodes.size() > 0) {
// draw the nodes
Iterator<DrawPanelNode> nodes = fast_nodes.iterator();
while (nodes.hasNext()) {
DrawPanelNode n = nodes.next();
if (running) {
if (n.line_number <= linesProcessed) {
gl2.glColor3f(1, 0, 0);
//g2d.setColor(Color.RED);
} else if (n.line_number <= linesProcessed + look_ahead) {
gl2.glColor3f(0, 1, 0);
//g2d.setColor(Color.GREEN);
} else if (prefs.getBoolean("Draw all while running", true) == false) {
break;
}
}
switch (n.type) {
case TOOL:
tool = machine.getTool(n.tool_id);
gl2.glLineWidth(tool.getDiameter() * (float) this.cameraZoom / 10.0f);
break;
case COLOR:
if (!running || n.line_number > linesProcessed + look_ahead) {
//g2d.setColor(n.c);
gl2.glColor3f(n.c.getRed() / 255.0f, n.c.getGreen() / 255.0f, n.c.getBlue() / 255.0f); |
<<<<<<<
=======
/*
>>>>>>>
<<<<<<<
for(start=0;start<numPoints-4 && !parent.isCancelled();++start) {
float a=calculateWeight(solution[start],solution[start+1]); // s1->s2
float b=calculateWeight(solution[start+1],solution[start+2]); // s2->s3
float d=calculateWeight(solution[start],solution[start+2]); // s1->s3
=======
for(start=0;start<numPoints-4 && !isCancelled();++start) {
float a=CalculateWeight(solution[start],solution[start+1]); // s1->s2
float b=CalculateWeight(solution[start+1],solution[start+2]); // s2->s3
float d=CalculateWeight(solution[start],solution[start+2]); // s1->s3
>>>>>>>
for(start=0;start<numPoints-4 && !parent.isCancelled();++start) {
float a=calculateWeight(solution[start],solution[start+1]); // s1->s2
float b=calculateWeight(solution[start+1],solution[start+2]); // s2->s3
float d=calculateWeight(solution[start],solution[start+2]); // s1->s3
<<<<<<<
for(end=start+4;end<numPoints && !parent.isCancelled();++end) {
=======
for(end=start+4;end<numPoints && !isCancelled();++end) {
>>>>>>>
for(end=start+4;end<numPoints && !parent.isCancelled();++end) {
<<<<<<<
if(best_end != -1 && !parent.isCancelled()) {
=======
if(best_end != -1 && !isCancelled()) {
>>>>>>>
if(best_end != -1 && !parent.isCancelled()) {
<<<<<<<
float d=calculateWeight(solution[start],solution[end-1]); // s1->e1
float e=calculateWeight(solution[end-1],solution[start+1]); // e1->s2
=======
float d=CalculateWeight(solution[start],solution[end-1]); // s1->e1
float e=CalculateWeight(solution[end-1],solution[start+1]); // e1->s2
>>>>>>>
float d=calculateWeight(solution[start],solution[end-1]); // s1->e1
float e=calculateWeight(solution[end-1],solution[start+1]); // e1->s2
<<<<<<<
if(best_end != -1 && !parent.isCancelled()) {
=======
if(best_end != -1 && !isCancelled()) {
>>>>>>>
if(best_end != -1 && !parent.isCancelled()) { |
<<<<<<<
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
=======
import javax.swing.*;
import java.awt.*;
>>>>>>>
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
<<<<<<<
import javax.swing.BorderFactory;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
=======
>>>>>>>
import javax.swing.BorderFactory;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JProgressBar; |
<<<<<<<
=======
>>>>>>>
<<<<<<<
import java.awt.Font;
//import java.awt.Shape;
//import java.awt.font.FontRenderContext;
//import java.awt.font.TextLayout;
//import java.awt.geom.PathIterator;
=======
>>>>>>>
import java.awt.Font;
//import java.awt.Shape;
//import java.awt.font.FontRenderContext;
//import java.awt.font.TextLayout;
//import java.awt.geom.PathIterator; |
<<<<<<<
/** GOOGLE COLORS **/
public static float[] gGreen = new float[] { 0f / 255f, 135f / 255f, 68f / 255f, 1f };
public static Color gGreenC =getCol(gGreen);
public static float[] gBlue = new float[] { 0f / 255f, 87f / 255f, 231f / 255f, 1f };
public static Color gBlueC =getCol(gBlue);
public static float[] gRed = new float[] { 214f / 255f, 45f / 255f, 32f / 255f, 1f };
public static Color gRedC =getCol(gRed);
public static float[] gYellow = new float[] { 255f / 255f, 167f / 255f, 0f / 255f, 1f };
public static Color gYellowC =getCol(gYellow);
public static float[] gWhite = new float[] { 255f / 255f, 255f / 255f, 255f / 255f, 1f };
public static Color gWhiteC =getCol(gWhite);
public static float[] gPink = new float[] { 255f / 255f, 102f / 255f, 255f / 255f, 1f };
public static Color gPinkC =getCol(gPink);
private static Color getCol(float[] c){
return new Color(c[0], c[1], c[2], c[3]);
}
/**
* Model for atmosphere scattering
*/
public static final String atmModelLocation = "models/atm/atm-uv.g3db";
=======
/** Instance **/
public static GlobalResources instance;
/** GOOGLE COLORS **/
public static float[] gGreen = new float[] { 0f / 255f, 135f / 255f, 68f / 255f, 1f };
public static Color gGreenC =getCol(gGreen);
public static float[] gBlue = new float[] { 0f / 255f, 87f / 255f, 231f / 255f, 1f };
public static Color gBlueC =getCol(gBlue);
public static float[] gRed = new float[] { 214f / 255f, 45f / 255f, 32f / 255f, 1f };
public static Color gRedC =getCol(gRed);
public static float[] gYellow = new float[] { 255f / 255f, 167f / 255f, 0f / 255f, 1f };
public static Color gYellowC =getCol(gYellow);
public static float[] gWhite = new float[] { 255f / 255f, 255f / 255f, 255f / 255f, 1f };
public static Color gWhiteC =getCol(gWhite);
public static float[] gPink = new float[] { 255f / 255f, 102f / 255f, 255f / 255f, 1f };
public static Color gPinkC =getCol(gPink);
private static Color getCol(float[] c){
return new Color(c[0], c[1], c[2], c[3]);
}
>>>>>>>
/** GOOGLE COLORS **/
public static float[] gGreen = new float[] { 0f / 255f, 135f / 255f, 68f / 255f, 1f };
public static Color gGreenC =getCol(gGreen);
public static float[] gBlue = new float[] { 0f / 255f, 87f / 255f, 231f / 255f, 1f };
public static Color gBlueC =getCol(gBlue);
public static float[] gRed = new float[] { 214f / 255f, 45f / 255f, 32f / 255f, 1f };
public static Color gRedC =getCol(gRed);
public static float[] gYellow = new float[] { 255f / 255f, 167f / 255f, 0f / 255f, 1f };
public static Color gYellowC =getCol(gYellow);
public static float[] gWhite = new float[] { 255f / 255f, 255f / 255f, 255f / 255f, 1f };
public static Color gWhiteC =getCol(gWhite);
public static float[] gPink = new float[] { 255f / 255f, 102f / 255f, 255f / 255f, 1f };
public static Color gPinkC =getCol(gPink);
private static Color getCol(float[] c){
return new Color(c[0], c[1], c[2], c[3]);
} |
<<<<<<<
public RotaryStewartPlatform2(EvilOverlord gui) {
super(gui);
setDisplayName(ROBOT_NAME);
=======
public RotaryStewartPlatform2() {
super();
setDisplayName("Rotary Stewart Platform 2");
>>>>>>>
public RotaryStewartPlatform2() {
super();
setDisplayName(ROBOT_NAME); |
<<<<<<<
import com.marginallyclever.robotOverlord.communications.AbstractConnectionManager;
import com.marginallyclever.robotOverlord.communications.SerialConnectionManager;
=======
import com.marginallyclever.robotOverlord.actions.ActionAbout;
import com.marginallyclever.robotOverlord.actions.ActionAddEntity;
import com.marginallyclever.robotOverlord.actions.ActionCheckForUpdate;
import com.marginallyclever.robotOverlord.actions.ActionLoad;
import com.marginallyclever.robotOverlord.actions.ActionNew;
import com.marginallyclever.robotOverlord.actions.ActionQuit;
import com.marginallyclever.robotOverlord.actions.ActionRedo;
import com.marginallyclever.robotOverlord.actions.ActionSaveAs;
import com.marginallyclever.robotOverlord.actions.ActionUndo;
>>>>>>>
import com.marginallyclever.robotOverlord.actions.ActionAbout;
import com.marginallyclever.robotOverlord.actions.ActionAddEntity;
import com.marginallyclever.robotOverlord.actions.ActionCheckForUpdate;
import com.marginallyclever.robotOverlord.actions.ActionLoad;
import com.marginallyclever.robotOverlord.actions.ActionNew;
import com.marginallyclever.robotOverlord.actions.ActionQuit;
import com.marginallyclever.robotOverlord.actions.ActionRedo;
import com.marginallyclever.robotOverlord.actions.ActionSaveAs;
import com.marginallyclever.robotOverlord.actions.ActionUndo;
import com.marginallyclever.robotOverlord.communications.AbstractConnectionManager;
import com.marginallyclever.robotOverlord.communications.SerialConnectionManager; |
<<<<<<<
import android.content.res.TypedArray;
=======
import android.support.annotation.NonNull;
>>>>>>>
import android.content.res.TypedArray;
import android.support.annotation.NonNull; |
<<<<<<<
* @param stopY The bottom boundary of the day number rect
=======
* @param stopY The bottom boundary of the day number rect
* @param isEnabled The flag to show if the day should look enabled or not
>>>>>>>
* @param stopY The bottom boundary of the day number rect
* @param stopY The bottom boundary of the day number rect
* @param isEnabled The flag to show if the day should look enabled or not
<<<<<<<
int x, int y, int startX, int stopX, int startY, int stopY);
=======
int x, int y, int startX, int stopX, int startY, int stopY, boolean isEnabled);
>>>>>>>
int x, int y, int startX, int stopX, int startY, int stopY, boolean isEnabled); |
<<<<<<<
import de.zalando.aruha.nakadi.controller.EventStreamController;
import de.zalando.aruha.nakadi.repository.TopicRepository;
import de.zalando.aruha.nakadi.repository.kafka.KafkaRepository;
=======
import com.codahale.metrics.MetricRegistry;
import com.codahale.metrics.health.HealthCheckRegistry;
import com.codahale.metrics.servlets.MetricsServlet;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.PropertyNamingStrategy;
import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;
import com.ryantenney.metrics.spring.config.annotation.EnableMetrics;
import com.ryantenney.metrics.spring.config.annotation.MetricsConfigurerAdapter;
import de.zalando.aruha.nakadi.repository.kafka.KafkaFactory;
import de.zalando.aruha.nakadi.repository.kafka.KafkaLocationManager;
>>>>>>>
import com.codahale.metrics.MetricRegistry;
import com.codahale.metrics.health.HealthCheckRegistry;
import com.codahale.metrics.servlets.MetricsServlet;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.PropertyNamingStrategy;
import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;
import com.ryantenney.metrics.spring.config.annotation.EnableMetrics;
import com.ryantenney.metrics.spring.config.annotation.MetricsConfigurerAdapter;
import de.zalando.aruha.nakadi.repository.kafka.KafkaFactory;
import de.zalando.aruha.nakadi.repository.kafka.KafkaLocationManager;
import de.zalando.aruha.nakadi.controller.EventStreamController;
import de.zalando.aruha.nakadi.repository.TopicRepository;
import de.zalando.aruha.nakadi.repository.kafka.KafkaRepository;
<<<<<<<
=======
import de.zalando.aruha.nakadi.repository.zookeeper.ZooKeeperHolder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
>>>>>>>
import de.zalando.aruha.nakadi.repository.zookeeper.ZooKeeperHolder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
<<<<<<<
import org.springframework.context.annotation.Profile;
=======
>>>>>>>
import org.springframework.context.annotation.Profile;
<<<<<<<
import com.codahale.metrics.MetricRegistry;
import com.codahale.metrics.servlets.MetricsServlet;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ryantenney.metrics.spring.config.annotation.EnableMetrics;
import com.ryantenney.metrics.spring.config.annotation.MetricsConfigurerAdapter;
import de.zalando.aruha.nakadi.repository.kafka.KafkaFactory;
import de.zalando.aruha.nakadi.repository.kafka.KafkaLocationManager;
import de.zalando.aruha.nakadi.repository.zookeeper.ZooKeeperHolder;
=======
import org.zalando.problem.ProblemModule;
>>>>>>>
import org.zalando.problem.ProblemModule;
import com.codahale.metrics.MetricRegistry;
import com.codahale.metrics.servlets.MetricsServlet;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ryantenney.metrics.spring.config.annotation.EnableMetrics;
import com.ryantenney.metrics.spring.config.annotation.MetricsConfigurerAdapter;
import de.zalando.aruha.nakadi.repository.kafka.KafkaFactory;
import de.zalando.aruha.nakadi.repository.kafka.KafkaLocationManager;
import de.zalando.aruha.nakadi.repository.zookeeper.ZooKeeperHolder;
<<<<<<<
return new ObjectMapper().setPropertyNamingStrategy(CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES);
=======
final ObjectMapper objectMapper = new ObjectMapper().setPropertyNamingStrategy(
PropertyNamingStrategy.CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES);
objectMapper.registerModule(new Jdk8Module());
objectMapper.registerModule(new ProblemModule());
return objectMapper;
>>>>>>>
final ObjectMapper objectMapper = new ObjectMapper().setPropertyNamingStrategy(
PropertyNamingStrategy.CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES);
objectMapper.registerModule(new Jdk8Module());
objectMapper.registerModule(new ProblemModule());
return objectMapper; |
<<<<<<<
// check if amount of streams <= the total amount of partitions
final Session[] sessions = getZk().listSessions();
final Partition[] partitions = getZk().listPartitions();
if (sessions.length >= partitions.length) {
=======
final Partition[] partitions = getZk().getTopology().getPartitions();
if (getZk().listSessions().size() >= partitions.length) {
>>>>>>>
// check if amount of streams <= the total amount of partitions
final Partition[] partitions = getZk().getTopology().getPartitions();
if (getZk().listSessions().size() >= partitions.length) { |
<<<<<<<
=======
import de.zalando.aruha.nakadi.domain.ConsumedEvent;
import java.util.Map;
>>>>>>> |
<<<<<<<
import java.util.Collections;
import java.util.List;
=======
>>>>>>> |
<<<<<<<
=======
import com.fasterxml.jackson.databind.ObjectMapper;
import org.json.JSONObject;
import org.junit.Before;
import org.junit.Test;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.test.web.servlet.MockMvc;
import org.zalando.nakadi.config.JsonConfig;
import org.zalando.nakadi.config.SecuritySettings;
import org.zalando.nakadi.domain.Storage;
import org.zalando.nakadi.security.ClientResolver;
import org.zalando.nakadi.service.Result;
import org.zalando.nakadi.service.StorageService;
import org.zalando.problem.Problem;
>>>>>>>
<<<<<<<
.setMessageConverters(new StringHttpMessageConverter(), TestUtils.JACKSON_2_HTTP_MESSAGE_CONVERTER)
.setCustomArgumentResolvers(new ClientResolver(securitySettings, featureToggleService))
=======
.setMessageConverters(new StringHttpMessageConverter(),
new MappingJackson2HttpMessageConverter(objectMapper))
.setCustomArgumentResolvers(new ClientResolver(securitySettings))
>>>>>>>
.setMessageConverters(new StringHttpMessageConverter(), TestUtils.JACKSON_2_HTTP_MESSAGE_CONVERTER)
.setCustomArgumentResolvers(new ClientResolver(securitySettings)) |
<<<<<<<
import de.zalando.aruha.nakadi.service.EventStreamFactory;
=======
import org.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
>>>>>>>
import org.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import de.zalando.aruha.nakadi.service.EventStreamFactory; |
<<<<<<<
import org.zalando.nakadi.Application;
import org.zalando.nakadi.config.SecuritySettings;
import org.zalando.nakadi.metrics.EventTypeMetricRegistry;
import org.zalando.nakadi.repository.EventTypeRepository;
import org.zalando.nakadi.repository.TopicRepository;
import org.zalando.nakadi.repository.TopicRepositoryHolder;
import org.zalando.nakadi.repository.db.EventTypeCache;
import org.zalando.nakadi.repository.db.EventTypeDbRepository;
import org.zalando.nakadi.repository.db.SubscriptionDbRepository;
import org.zalando.nakadi.repository.kafka.KafkaLocationManager;
import org.zalando.nakadi.repository.zookeeper.ZooKeeperHolder;
import org.zalando.nakadi.service.CursorsService;
import org.zalando.nakadi.service.EventPublisher;
import org.zalando.nakadi.service.EventStreamFactory;
import org.zalando.nakadi.service.EventTypeService;
import org.zalando.nakadi.service.timeline.TimelineSync;
import org.zalando.nakadi.util.FeatureToggleService;
import org.zalando.nakadi.util.UUIDGenerator;
=======
import org.zalando.nakadi.Application;
import org.zalando.nakadi.config.SecuritySettings;
import org.zalando.nakadi.domain.Storage;
import org.zalando.nakadi.exceptions.InternalNakadiException;
import org.zalando.nakadi.metrics.EventTypeMetricRegistry;
import org.zalando.nakadi.repository.EventTypeRepository;
import org.zalando.nakadi.repository.db.EventTypeCache;
import org.zalando.nakadi.repository.db.EventTypeDbRepository;
import org.zalando.nakadi.repository.db.StorageDbRepository;
import org.zalando.nakadi.repository.db.SubscriptionDbRepository;
import org.zalando.nakadi.repository.kafka.KafkaLocationManager;
import org.zalando.nakadi.repository.kafka.KafkaTopicRepository;
import org.zalando.nakadi.repository.tool.DefaultStorage;
import org.zalando.nakadi.repository.zookeeper.ZooKeeperHolder;
import org.zalando.nakadi.service.CursorsService;
import org.zalando.nakadi.service.EventPublisher;
import org.zalando.nakadi.service.EventStreamFactory;
import org.zalando.nakadi.service.EventTypeService;
import org.zalando.nakadi.service.timeline.TimelineSync;
import org.zalando.nakadi.util.FeatureToggleService;
import org.zalando.nakadi.util.UUIDGenerator;
>>>>>>>
import org.zalando.nakadi.Application;
import org.zalando.nakadi.config.SecuritySettings;
import org.zalando.nakadi.domain.Storage;
import org.zalando.nakadi.exceptions.InternalNakadiException;
import org.zalando.nakadi.metrics.EventTypeMetricRegistry;
import org.zalando.nakadi.repository.EventTypeRepository;
import org.zalando.nakadi.repository.TopicRepository;
import org.zalando.nakadi.repository.TopicRepositoryHolder;
import org.zalando.nakadi.repository.db.EventTypeCache;
import org.zalando.nakadi.repository.db.EventTypeDbRepository;
import org.zalando.nakadi.repository.db.StorageDbRepository;
import org.zalando.nakadi.repository.db.SubscriptionDbRepository;
import org.zalando.nakadi.repository.kafka.KafkaLocationManager;
import org.zalando.nakadi.repository.tool.DefaultStorage;
import org.zalando.nakadi.repository.zookeeper.ZooKeeperHolder;
import org.zalando.nakadi.service.CursorsService;
import org.zalando.nakadi.service.EventPublisher;
import org.zalando.nakadi.service.EventStreamFactory;
import org.zalando.nakadi.service.EventTypeService;
import org.zalando.nakadi.service.timeline.TimelineSync;
import org.zalando.nakadi.util.FeatureToggleService;
import org.zalando.nakadi.util.UUIDGenerator;
<<<<<<<
@Bean
public TopicRepositoryHolder topicRepositoryHolder() {
return mock(TopicRepositoryHolder.class);
}
=======
@Bean
public DefaultStorage defaultStorage() throws InternalNakadiException {
final StorageDbRepository storageDbRepository = mock(StorageDbRepository.class);
when(storageDbRepository.getStorage("default")).thenReturn(Optional.of(new Storage()));
final DefaultStorage defaultStorage = new DefaultStorage(storageDbRepository, mock(Environment.class));
return defaultStorage;
}
>>>>>>>
@Bean
public TopicRepositoryHolder topicRepositoryHolder() {
return mock(TopicRepositoryHolder.class);
}
@Bean
public DefaultStorage defaultStorage() throws InternalNakadiException {
final StorageDbRepository storageDbRepository = mock(StorageDbRepository.class);
when(storageDbRepository.getStorage("default")).thenReturn(Optional.of(new Storage()));
final DefaultStorage defaultStorage = new DefaultStorage(storageDbRepository, mock(Environment.class));
return defaultStorage;
} |
<<<<<<<
import java.security.Principal;
=======
import java.io.IOException;
import java.util.ArrayList;
>>>>>>>
import java.security.Principal;
import java.io.IOException;
import java.util.ArrayList;
<<<<<<<
private static Principal mockPrincipal(final String clientId) {
final Principal principal = mock(Principal.class);
when(principal.getName()).thenReturn(clientId);
return principal;
}
=======
public EventTypeControllerTest() throws IOException {
}
>>>>>>>
private static Principal mockPrincipal(final String clientId) {
final Principal principal = mock(Principal.class);
when(principal.getName()).thenReturn(clientId);
return principal;
}
public EventTypeControllerTest() throws IOException {
} |
<<<<<<<
import org.zalando.nakadi.domain.Timeline;
=======
import org.zalando.nakadi.domain.EventTypeBase;
import org.zalando.nakadi.domain.Timeline;
>>>>>>>
import org.zalando.nakadi.domain.EventTypeBase;
import org.zalando.nakadi.domain.Timeline;
<<<<<<<
Mockito.when(ts.getTopicRepository(any())).thenReturn(topicRepository);
final Timeline timeline = Mockito.mock(Timeline.class);
Mockito.when(ts.getTimeline(any())).thenReturn(timeline);
=======
Mockito.when(ts.getTopicRepository((Timeline) any())).thenReturn(topicRepository);
Mockito.when(ts.getTopicRepository((EventTypeBase) any())).thenReturn(topicRepository);
>>>>>>>
Mockito.when(ts.getTopicRepository((Timeline) any())).thenReturn(topicRepository);
Mockito.when(ts.getTopicRepository((EventTypeBase) any())).thenReturn(topicRepository);
final Timeline timeline = Mockito.mock(Timeline.class);
Mockito.when(ts.getTimeline(any())).thenReturn(timeline); |
<<<<<<<
import org.zalando.nakadi.domain.TopicPartition;
=======
import org.zalando.nakadi.exceptions.IllegalScopeException;
>>>>>>>
import org.zalando.nakadi.domain.TopicPartition;
import org.zalando.nakadi.exceptions.IllegalScopeException;
<<<<<<<
=======
import org.zalando.nakadi.security.Client;
import org.zalando.nakadi.service.subscription.model.Partition;
>>>>>>>
import org.zalando.nakadi.security.Client; |
<<<<<<<
import de.zalando.aruha.nakadi.exceptions.InvalidPartitioningKeyFieldsException;
=======
import de.zalando.aruha.nakadi.exceptions.InternalNakadiException;
import de.zalando.aruha.nakadi.exceptions.InvalidOrderingKeyFieldsException;
>>>>>>>
import de.zalando.aruha.nakadi.exceptions.InternalNakadiException;
import de.zalando.aruha.nakadi.exceptions.InvalidPartitioningKeyFieldsException;
<<<<<<<
private final PartitioningStrategy partitioningKeyFieldsPartitioningStrategy = new PartitioningKeyFieldsPartitioningStrategy();
private final ValidationStrategy validationStrategy = new EventBodyMustRespectSchema();
private final ValidationStrategyConfiguration vsc = new ValidationStrategyConfiguration();
=======
private final EventTypeCache cache;
private final PartitioningStrategy orderingKeyFieldsPartitioningStrategy = new OrderingKeyFieldsPartitioningStrategy();
>>>>>>>
private final PartitioningStrategy partitioningKeyFieldsPartitioningStrategy = new PartitioningKeyFieldsPartitioningStrategy();
private final EventTypeCache cache; |
<<<<<<<
import org.zalando.nakadi.exceptions.runtime.InconsistentStateException;
import org.zalando.nakadi.exceptions.runtime.RepositoryProblemException;
=======
import org.zalando.nakadi.repository.EventConsumer;
import org.zalando.nakadi.repository.MultiTimelineEventConsumer;
>>>>>>>
import org.zalando.nakadi.repository.EventConsumer;
import org.zalando.nakadi.repository.MultiTimelineEventConsumer;
import org.zalando.nakadi.exceptions.runtime.InconsistentStateException;
import org.zalando.nakadi.exceptions.runtime.RepositoryProblemException;
<<<<<<<
private void switchTimelines(final Timeline activeTimeline, final Timeline nextTimeline)
throws InconsistentStateException, RepositoryProblemException, TimelineException, ConflictException {
=======
public EventConsumer createEventConsumer(final String clientId, final List<NakadiCursor> positions)
throws NakadiException, InvalidCursorException {
final MultiTimelineEventConsumer result = new MultiTimelineEventConsumer(clientId, this, timelineSync);
result.reassign(positions);
return result;
}
private void switchTimelines(final Timeline activeTimeline, final Timeline nextTimeline) {
>>>>>>>
public EventConsumer createEventConsumer(final String clientId, final List<NakadiCursor> positions)
throws NakadiException, InvalidCursorException {
final MultiTimelineEventConsumer result = new MultiTimelineEventConsumer(clientId, this, timelineSync);
result.reassign(positions);
return result;
}
private void switchTimelines(final Timeline activeTimeline, final Timeline nextTimeline)
throws InconsistentStateException, RepositoryProblemException, TimelineException, ConflictException { |
<<<<<<<
Result<Void> result = service.delete(eventTypeName, client);
if (!result.isSuccessful()) {
return Responses.create(result.getProblem(), request);
=======
try {
final EventType eventType = eventTypeRepository.findByName(eventTypeName);
eventTypeRepository.removeEventType(eventTypeName);
topicRepository.deleteTopic(eventType.getTopic());
return status(HttpStatus.OK).build();
} catch (final NoSuchEventTypeException e) {
LOG.warn("Tried to remove EventType " + eventTypeName + " that doesn't exist", e);
return create(e.asProblem(), nativeWebRequest);
} catch (final TopicDeletionException e) {
LOG.error("Problem deleting kafka topic " + eventTypeName, e);
return create(e.asProblem(), nativeWebRequest);
} catch (final NakadiException e) {
LOG.error("Error deleting event type " + eventTypeName, e);
return create(e.asProblem(), nativeWebRequest);
>>>>>>>
final Result<Void> result = service.delete(eventTypeName, client);
if (!result.isSuccessful()) {
return Responses.create(result.getProblem(), request); |
<<<<<<<
=======
import org.hamcrest.core.StringContains;
import org.junit.Before;
import org.junit.Test;
import org.zalando.nakadi.config.JsonConfig;
import org.zalando.nakadi.domain.Cursor;
>>>>>>>
import org.hamcrest.core.StringContains;
import org.junit.Before;
import org.junit.Test;
import org.zalando.nakadi.config.JsonConfig;
import org.zalando.nakadi.domain.Cursor;
<<<<<<<
import org.zalando.nakadi.domain.SubscriptionCursor;
=======
import org.zalando.nakadi.domain.SubscriptionEventTypeStats;
import org.zalando.nakadi.utils.JsonTestHelper;
>>>>>>>
import org.zalando.nakadi.domain.SubscriptionEventTypeStats;
import org.zalando.nakadi.utils.JsonTestHelper;
import org.zalando.nakadi.domain.SubscriptionCursor;
<<<<<<<
import static org.zalando.nakadi.domain.SubscriptionBase.InitialPosition.BEGIN;
import static org.zalando.nakadi.utils.RandomSubscriptionBuilder.randomSubscription;
import static org.zalando.nakadi.utils.TestUtils.waitFor;
import static org.zalando.nakadi.webservice.hila.StreamBatch.MatcherIgnoringToken.equalToBatchIgnoringToken;
import static org.zalando.nakadi.webservice.hila.StreamBatch.singleEventBatch;
import static org.zalando.nakadi.webservice.utils.NakadiTestUtils.commitCursors;
import static org.zalando.nakadi.webservice.utils.NakadiTestUtils.createEventType;
import static org.zalando.nakadi.webservice.utils.NakadiTestUtils.createSubscription;
import static org.zalando.nakadi.webservice.utils.NakadiTestUtils.publishEvent;
=======
>>>>>>>
import static org.zalando.nakadi.domain.SubscriptionBase.InitialPosition.BEGIN;
import static org.zalando.nakadi.utils.RandomSubscriptionBuilder.randomSubscription;
import static org.zalando.nakadi.utils.TestUtils.waitFor;
import static org.zalando.nakadi.webservice.hila.StreamBatch.MatcherIgnoringToken.equalToBatchIgnoringToken;
import static org.zalando.nakadi.webservice.hila.StreamBatch.singleEventBatch;
import static org.zalando.nakadi.webservice.utils.NakadiTestUtils.commitCursors;
import static org.zalando.nakadi.webservice.utils.NakadiTestUtils.createEventType;
import static org.zalando.nakadi.webservice.utils.NakadiTestUtils.createSubscription;
import static org.zalando.nakadi.webservice.utils.NakadiTestUtils.publishEvent; |
<<<<<<<
throws ServiceUnavailableException, NoSuchSubscriptionException, CursorUnavailableException,
UnableProcessException, IllegalScopeException, OperationTimeoutException, ZookeeperException,
=======
throws ServiceUnavailableException, NoSuchSubscriptionException,
UnableProcessException, OperationTimeoutException, ZookeeperException,
>>>>>>>
throws ServiceUnavailableException, NoSuchSubscriptionException, CursorUnavailableException,
UnableProcessException, OperationTimeoutException, ZookeeperException,
<<<<<<<
validateSubscriptionResetCursors(subscription, cursors);
validateSubscriptionReadScopes(subscription, client);
=======
validateSubscriptionCursors(subscription, cursors);
>>>>>>>
validateSubscriptionResetCursors(subscription, cursors);
<<<<<<<
private void validateSubscriptionResetCursors(final Subscription subscription, final List<NakadiCursor> cursors)
throws ServiceUnavailableException, CursorUnavailableException {
validateCursorsBelongToSubscription(subscription, cursors);
final Map<TopicRepository, List<NakadiCursor>> cursorsByRepo = cursors.stream()
.collect(Collectors.groupingBy(c -> timelineService.getTopicRepository(c.getTimeline())));
for (final Map.Entry<TopicRepository, List<NakadiCursor>> repoEntry : cursorsByRepo.entrySet()) {
final TopicRepository topicRepository = repoEntry.getKey();
final List<NakadiCursor> cursorsForRepo = repoEntry.getValue();
try {
topicRepository.validateReadCursors(cursorsForRepo);
} catch (final InvalidCursorException e) {
throw new CursorUnavailableException(e.getMessage(), e);
}
}
}
private void validateCursorsBelongToSubscription(final Subscription subscription, final List<NakadiCursor> cursors)
throws UnableProcessException {
final List<String> wrongEventTypes = cursors.stream()
.map(NakadiCursor::getEventType)
.filter(et -> !subscription.getEventTypes().contains(et))
.collect(Collectors.toList());
if (!wrongEventTypes.isEmpty()) {
throw new UnableProcessException("Event type does not belong to subscription: " + wrongEventTypes);
}
}
private void validateSubscriptionReadScopes(final Subscription subscription, final Client client)
throws ServiceUnavailableException, NoSuchSubscriptionException, IllegalScopeException {
subscription.getEventTypes().stream().map(Try.wrap(eventTypeRepository::findByName))
.map(Try::getOrThrow)
.forEach(eventType -> client.checkScopes(eventType.getReadScopes()));
}
=======
>>>>>>>
private void validateSubscriptionResetCursors(final Subscription subscription, final List<NakadiCursor> cursors)
throws ServiceUnavailableException, CursorUnavailableException {
validateCursorsBelongToSubscription(subscription, cursors);
final Map<TopicRepository, List<NakadiCursor>> cursorsByRepo = cursors.stream()
.collect(Collectors.groupingBy(c -> timelineService.getTopicRepository(c.getTimeline())));
for (final Map.Entry<TopicRepository, List<NakadiCursor>> repoEntry : cursorsByRepo.entrySet()) {
final TopicRepository topicRepository = repoEntry.getKey();
final List<NakadiCursor> cursorsForRepo = repoEntry.getValue();
try {
topicRepository.validateReadCursors(cursorsForRepo);
} catch (final InvalidCursorException e) {
throw new CursorUnavailableException(e.getMessage(), e);
}
}
}
private void validateCursorsBelongToSubscription(final Subscription subscription, final List<NakadiCursor> cursors)
throws UnableProcessException {
final List<String> wrongEventTypes = cursors.stream()
.map(NakadiCursor::getEventType)
.filter(et -> !subscription.getEventTypes().contains(et))
.collect(Collectors.toList());
if (!wrongEventTypes.isEmpty()) {
throw new UnableProcessException("Event type does not belong to subscription: " + wrongEventTypes);
}
} |
<<<<<<<
private final EventTypeRepository eventTypeRepository = mock(EventTypeRepository.class);
private final TopicRepository topicRepository = mock(TopicRepository.class);
=======
public static final String EVENT_TYPE_NAME = "event-name";
private final EventTypeRepository repo = mock(EventTypeRepository.class);
>>>>>>>
private final EventTypeRepository eventTypeRepository = mock(EventTypeRepository.class);
private final TopicRepository topicRepository = mock(TopicRepository.class);
public static final String EVENT_TYPE_NAME = "event-name";
<<<<<<<
.when(eventTypeRepository)
.findByName("event-name");
=======
.when(repo)
.findByName(EVENT_TYPE_NAME);
>>>>>>>
.when(eventTypeRepository)
.findByName(EVENT_TYPE_NAME);
<<<<<<<
.when(eventTypeRepository)
.findByName("event-name");
=======
.when(repo)
.findByName(EVENT_TYPE_NAME);
>>>>>>>
.when(eventTypeRepository)
.findByName(EVENT_TYPE_NAME);
<<<<<<<
.when(eventTypeRepository)
.findByName("event-name");
=======
.when(repo)
.findByName(EVENT_TYPE_NAME);
>>>>>>>
.when(eventTypeRepository)
.findByName(EVENT_TYPE_NAME);
<<<<<<<
.when(eventTypeRepository)
.findByName("event-name");
=======
.when(repo)
.findByName(EVENT_TYPE_NAME);
>>>>>>>
.when(eventTypeRepository)
.findByName(EVENT_TYPE_NAME); |
<<<<<<<
import static org.junit.Assert.assertEquals;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doNothing;
=======
import static org.mockito.Matchers.any;
>>>>>>>
import static org.junit.Assert.assertEquals;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doNothing;
<<<<<<<
private final AuthorizationService authorizationService;
private final NakadiSettings nakadiSettings;
private final List<Permission> adminList;
final List<Permission> defaultAdminPermissions;
final AuthorizationAttribute user1 = new ResourceAuthorizationAttribute("user", "user1");
final AuthorizationAttribute user2 = new ResourceAuthorizationAttribute("user", "user2");
final AuthorizationAttribute service2 = new ResourceAuthorizationAttribute("service", "service2");
final List<AuthorizationAttribute> newAttrs = Arrays.asList(user1, user2, service2);
final Permission permAdminUser1 = new Permission("nakadi", AuthorizationService.Operation.ADMIN,
new ResourceAuthorizationAttribute("user", "user1"));
final Permission permAdminService1 = new Permission("nakadi", AuthorizationService.Operation.ADMIN,
new ResourceAuthorizationAttribute("service", "service1"));
final Permission permAdminService2 = new Permission("nakadi", AuthorizationService.Operation.ADMIN,
new ResourceAuthorizationAttribute("service", "service2"));
final Permission permReadUser1 = new Permission("nakadi", AuthorizationService.Operation.READ,
new ResourceAuthorizationAttribute("user", "user1"));
final Permission permReadService1 = new Permission("nakadi", AuthorizationService.Operation.READ,
new ResourceAuthorizationAttribute("service", "service1"));
final Permission permReadService2 = new Permission("nakadi", AuthorizationService.Operation.READ,
new ResourceAuthorizationAttribute("service", "service2"));
final Permission permWriteUser1 = new Permission("nakadi", AuthorizationService.Operation.WRITE,
new ResourceAuthorizationAttribute("user", "user1"));
final Permission permWriteService1 = new Permission("nakadi", AuthorizationService.Operation.WRITE,
new ResourceAuthorizationAttribute("service", "service1"));
final Permission permWriteService2 = new Permission("nakadi", AuthorizationService.Operation.WRITE,
new ResourceAuthorizationAttribute("service", "service2"));
final ResourceAuthorization newAuthz = new ResourceAuthorization(newAttrs, newAttrs, newAttrs);
final AuthorizationAttribute defaultAdmin = new ResourceAuthorizationAttribute("service", "nakadi");
=======
private final AuthorizationService authorizationService;
>>>>>>>
private final AuthorizationService authorizationService;
private final NakadiSettings nakadiSettings;
private final List<Permission> adminList;
<<<<<<<
this.authorizationService = mock(AuthorizationService.class);
this.nakadiSettings = mock(NakadiSettings.class);
this.adminService = new AdminService(authorizationDbRepository, authorizationService, nakadiSettings);
this.adminList = new ArrayList<>(Arrays.asList(permAdminUser1, permAdminService1,
permAdminService2, permReadUser1, permReadService1, permReadService2, permWriteUser1,
permWriteService1, permWriteService2));
this.defaultAdminPermissions = new ArrayList<>();
for (final AuthorizationService.Operation operation: AuthorizationService.Operation.values()) {
defaultAdminPermissions.add(new Permission("nakadi", operation, defaultAdmin));
}
=======
this.authorizationService = mock(AuthorizationService.class);
this.adminService = new AdminService(authorizationDbRepository, authorizationService);
>>>>>>>
this.authorizationService = mock(AuthorizationService.class);
this.nakadiSettings = mock(NakadiSettings.class);
this.adminService = new AdminService(authorizationDbRepository, authorizationService, nakadiSettings);
this.adminList = new ArrayList<>(Arrays.asList(permAdminUser1, permAdminService1,
permAdminService2, permReadUser1, permReadService1, permReadService2, permWriteUser1,
permWriteService1, permWriteService2));
this.defaultAdminPermissions = new ArrayList<>();
for (final AuthorizationService.Operation operation : AuthorizationService.Operation.values()) {
defaultAdminPermissions.add(new Permission("nakadi", operation, defaultAdmin));
}
when(authorizationService.isAuthorizationAttributeValid(any())).thenReturn(true);
<<<<<<<
when(authorizationDbRepository.listAdmins()).thenReturn(adminList);
=======
final AuthorizationAttribute user1 = new ResourceAuthorizationAttribute("user", "user1");
final AuthorizationAttribute user2 = new ResourceAuthorizationAttribute("user", "user2");
final AuthorizationAttribute service2 = new ResourceAuthorizationAttribute("service", "service2");
final List<AuthorizationAttribute> newAttrs = Arrays.asList(user1, user2, service2);
final Permission permAdminUser1 = new Permission("nakadi", AuthorizationService.Operation.ADMIN,
new ResourceAuthorizationAttribute("user", "user1"));
final Permission permAdminService1 = new Permission("nakadi", AuthorizationService.Operation.ADMIN,
new ResourceAuthorizationAttribute("service", "service1"));
final Permission permAdminService2 = new Permission("nakadi", AuthorizationService.Operation.ADMIN,
new ResourceAuthorizationAttribute("service", "service2"));
final Permission permReadUser1 = new Permission("nakadi", AuthorizationService.Operation.READ,
new ResourceAuthorizationAttribute("user", "user1"));
final Permission permReadService1 = new Permission("nakadi", AuthorizationService.Operation.READ,
new ResourceAuthorizationAttribute("service", "service1"));
final Permission permReadService2 = new Permission("nakadi", AuthorizationService.Operation.READ,
new ResourceAuthorizationAttribute("service", "service2"));
final Permission permWriteUser1 = new Permission("nakadi", AuthorizationService.Operation.WRITE,
new ResourceAuthorizationAttribute("user", "user1"));
final Permission permWriteService1 = new Permission("nakadi", AuthorizationService.Operation.WRITE,
new ResourceAuthorizationAttribute("service", "service1"));
final Permission permWriteService2 = new Permission("nakadi", AuthorizationService.Operation.WRITE,
new ResourceAuthorizationAttribute("service", "service2"));
final ResourceAuthorization newAuthz = new ResourceAuthorization(newAttrs, newAttrs, newAttrs);
when(authorizationDbRepository.listAdmins()).thenReturn(Arrays.asList(permAdminUser1, permAdminService1,
permAdminService2, permReadUser1, permReadService1, permReadService2, permWriteUser1,
permWriteService1, permWriteService2));
when(authorizationService.isAuthorizationAttributeValid(any())).thenReturn(true);
>>>>>>>
when(authorizationDbRepository.listAdmins()).thenReturn(adminList); |
<<<<<<<
import com.mycelium.wapi.wallet.btc.coins.BitcoinTest;
=======
>>>>>>>
import com.mycelium.wapi.wallet.btc.coins.BitcoinTest;
<<<<<<<
_mbwManager.getDenomination().getUnicodeString(_account.getCoinType().getSymbol())));
=======
_account.getCoinType() == Utils.getBtcCoinType()
? _mbwManager.getBitcoinDenomination().toString()
: _account.getCoinType().getSymbol()));
>>>>>>>
_mbwManager.getDenomination().getUnicodeString(_account.getCoinType().getSymbol())));
<<<<<<<
? _mbwManager.getFiatCurrency() : _account.getCoinType());
String sendAmount = ValueExtensionsKt.toStringWithUnit(primaryAmount, _mbwManager.getDenomination());
if (!primaryAmount.getCurrencySymbol().equals("BTC")) {
=======
? _mbwManager.getFiatCurrency()
: _account.getCoinType());
String sendAmount = ValueExtensionsKt.toStringWithUnit(primaryAmount, _mbwManager.getBitcoinDenomination());
if (!primaryAmount.getCurrencySymbol().equals(Utils.getBtcCoinType().getSymbol())) {
>>>>>>>
? _mbwManager.getFiatCurrency() : _account.getCoinType());
String sendAmount = ValueExtensionsKt.toStringWithUnit(primaryAmount, _mbwManager.getDenomination());
if (!primaryAmount.getCurrencySymbol().equals(Utils.getBtcCoinType().getSymbol())) { |
<<<<<<<
=======
private static final UriComponentsBuilder SUBSCRIPTION_PATH = UriComponentsBuilder.fromPath("/subscriptions/{id}");
>>>>>>>
private static final UriComponentsBuilder SUBSCRIPTION_PATH = UriComponentsBuilder.fromPath("/subscriptions/{id}"); |
<<<<<<<
.body("audience", equalTo("external-public"))
=======
.body("audience", equalTo("external_public"))
.body("ordering_key_fields", equalTo(Lists.newArrayList("foo", "bar.baz")))
>>>>>>>
.body("audience", equalTo("external-public"))
.body("ordering_key_fields", equalTo(Lists.newArrayList("foo", "bar.baz"))) |
<<<<<<<
import de.zalando.aruha.nakadi.config.JsonConfig;
=======
import com.google.common.base.Charsets;
import com.google.common.io.Resources;
import de.zalando.aruha.nakadi.config.NakadiConfig;
>>>>>>>
import com.google.common.base.Charsets;
import com.google.common.io.Resources;
import de.zalando.aruha.nakadi.config.JsonConfig; |
<<<<<<<
import de.zalando.aruha.nakadi.problem.ValidationProblem;
import org.apache.commons.io.IOUtils;
import org.echocat.jomon.runtime.concurrent.RetryForSpecifiedTimeStrategy;
import org.json.JSONObject;
=======
>>>>>>>
import de.zalando.aruha.nakadi.problem.ValidationProblem;
import org.apache.commons.io.IOUtils;
import org.echocat.jomon.runtime.concurrent.RetryForSpecifiedTimeStrategy;
import org.json.JSONObject;
<<<<<<<
import static org.echocat.jomon.runtime.concurrent.Retryer.executeWithRetry;
=======
import java.io.IOException;
import java.util.Arrays;
import java.util.Random;
import java.util.UUID;
>>>>>>>
import java.io.IOException;
import java.util.Arrays;
import java.util.Random;
import java.util.UUID;
import static org.echocat.jomon.runtime.concurrent.Retryer.executeWithRetry; |
<<<<<<<
import org.zalando.nakadi.service.timeline.TimelineService;
import org.zalando.nakadi.view.Cursor;
=======
import org.zalando.nakadi.service.CursorConverter;
>>>>>>>
import org.zalando.nakadi.service.CursorConverter;
import org.zalando.nakadi.service.timeline.TimelineService;
<<<<<<<
private final TimelineService timelineService;
=======
private final TopicRepository topicRepository;
private final CursorConverter cursorConverter;
>>>>>>>
private final TimelineService timelineService;
private final CursorConverter cursorConverter;
<<<<<<<
public PartitionsController(final EventTypeRepository eventTypeRepository, final TimelineService timelineService) {
=======
public PartitionsController(final EventTypeRepository eventTypeRepository, final TopicRepository topicRepository,
final CursorConverter cursorConverter) {
>>>>>>>
public PartitionsController(final EventTypeRepository eventTypeRepository,
final TimelineService timelineService,
final CursorConverter cursorConverter) {
<<<<<<<
this.timelineService = timelineService;
=======
this.topicRepository = topicRepository;
this.cursorConverter = cursorConverter;
>>>>>>>
this.timelineService = timelineService;
this.cursorConverter = cursorConverter;
<<<<<<<
// FIXME TIMELINE: IT HAS TO BE FIXED TO SUPPORT MULTIPLE TL
// Cursors here might be in different timeline
Cursor.fromTopicPosition(stat.getFirst()).getOffset(),
Cursor.fromTopicPosition(stat.getLast()).getOffset()))
=======
cursorConverter.convert(stat.getFirst()).getOffset(),
cursorConverter.convert(stat.getLast()).getOffset()))
>>>>>>>
// FIXME TIMELINE: IT HAS TO BE FIXED TO SUPPORT MULTIPLE TL
// Cursors here might be in different timeline
cursorConverter.convert(stat.getFirst()).getOffset(),
cursorConverter.convert(stat.getLast()).getOffset())) |
<<<<<<<
if (!adminService.isAdmin(AuthorizationService.Operation.READ)) {
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
}
return ResponseEntity.ok(AdminAuthorization.fromPermissionsList(adminService.getAdmins()));
=======
return ResponseEntity.ok(ResourceAuthorization.fromPermissionsList(adminService.getAdmins()));
>>>>>>>
if (!adminService.isAdmin(AuthorizationService.Operation.READ)) {
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
}
return ResponseEntity.ok(ResourceAuthorization.fromPermissionsList(adminService.getAdmins()));
<<<<<<<
public ResponseEntity<?> updateAdmins(@Valid @RequestBody final AdminAuthorization authz) {
if (!adminService.isAdmin(AuthorizationService.Operation.ADMIN)) {
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
}
adminService.updateAdmins(authz.toPermissionsList(ADMIN_RESOURCE));
=======
public ResponseEntity<?> updateAdmins(@Valid @RequestBody final ResourceAuthorization authz) {
adminService.updateAdmins(authz.toPermissionsList("nakadi"));
>>>>>>>
public ResponseEntity<?> updateAdmins(@Valid @RequestBody final ResourceAuthorization authz) {
if (!adminService.isAdmin(AuthorizationService.Operation.ADMIN)) {
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
}
adminService.updateAdmins(authz.toPermissionsList(ADMIN_RESOURCE)); |
<<<<<<<
=======
import de.zalando.aruha.nakadi.domain.BatchItem;
import de.zalando.aruha.nakadi.domain.EventCategory;
import de.zalando.aruha.nakadi.domain.EventType;
import de.zalando.aruha.nakadi.domain.EventTypeSchema;
>>>>>>>
import de.zalando.aruha.nakadi.domain.BatchItem;
import de.zalando.aruha.nakadi.domain.EventCategory;
import de.zalando.aruha.nakadi.domain.EventType;
import de.zalando.aruha.nakadi.domain.EventTypeSchema;
<<<<<<<
public static void waitFor(final Runnable runnable) {
waitFor(runnable, 10000, 500);
}
public static void waitFor(final Runnable runnable, final int timeoutMs) {
waitFor(runnable, timeoutMs, 500);
}
@SuppressWarnings("unchecked")
public static void waitFor(final Runnable runnable, final int timeoutMs, final int intervalMs) {
executeWithRetry(
runnable,
new RetryForSpecifiedTimeStrategy<Void>(timeoutMs)
.withExceptionsThatForceRetry(AssertionError.class)
.withWaitBetweenEachTry(intervalMs));
}
=======
public static BatchItem createBatch(JSONObject event) {
return new BatchItem(event);
}
>>>>>>>
public static void waitFor(final Runnable runnable) {
waitFor(runnable, 10000, 500);
}
public static void waitFor(final Runnable runnable, final int timeoutMs) {
waitFor(runnable, timeoutMs, 500);
}
@SuppressWarnings("unchecked")
public static void waitFor(final Runnable runnable, final int timeoutMs, final int intervalMs) {
executeWithRetry(
runnable,
new RetryForSpecifiedTimeStrategy<Void>(timeoutMs)
.withExceptionsThatForceRetry(AssertionError.class)
.withWaitBetweenEachTry(intervalMs));
}
public static BatchItem createBatch(JSONObject event) {
return new BatchItem(event);
} |
<<<<<<<
return Result.ok(new SubscriptionListWrapper(subscriptions, paginationLinks));
} catch (final ServiceUnavailableException e) {
=======
return Result.ok(new PaginationWrapper(subscriptions, paginationLinks));
} catch (ServiceUnavailableException e) {
>>>>>>>
return Result.ok(new PaginationWrapper(subscriptions, paginationLinks));
} catch (final ServiceUnavailableException e) { |
<<<<<<<
for (final String partition : getPartitionsList(eventType)) {
resultPartitions.add(getPartitionStats(subscriptionNode, eventType.getName(), partition, null, null));
=======
final List<String> partitionsList = subscriptionNode.map(
node -> node.getPartitions().stream()
.map(Partition::getPartition)
.collect(Collectors.toList()))
.orElseGet(() -> getPartitionsList(eventType));
for (final String partition : partitionsList) {
resultPartitions.add(getPartitionStats(subscriptionNode, eventType.getName(), partition, null));
>>>>>>>
final List<String> partitionsList = subscriptionNode.map(
node -> node.getPartitions().stream()
.map(Partition::getPartition)
.collect(Collectors.toList()))
.orElseGet(() -> getPartitionsList(eventType));
for (final String partition : partitionsList) {
resultPartitions.add(getPartitionStats(subscriptionNode, eventType.getName(), partition, null, null)); |
<<<<<<<
import java.util.Objects;
import java.util.stream.Collectors;
=======
>>>>>>>
import java.util.Objects;
import java.util.stream.Collectors;
<<<<<<<
public ResponseEntity<?> exposeSingleEventType(@PathVariable final String name, final NativeWebRequest nativeWebRequest) {
try {
final EventType eventType = eventTypeRepository.findByName(name);
return status(HttpStatus.OK).body(eventType);
} catch (final NoSuchEventTypeException e) {
LOG.debug("Could not find EventType: {}", name);
return create(e.asProblem(), nativeWebRequest);
} catch (final InternalNakadiException e) {
LOG.error("Problem loading event type " + name, e);
return create(e.asProblem(), nativeWebRequest);
}
}
private void validatePartitionKeys(final EventType eventType) throws InvalidEventTypeException {
try {
final JSONObject schemaAsJson = new JSONObject(eventType.getSchema().getSchema());
final List<String> absentFields = eventType.getPartitionKeyFields().stream()
.filter(field -> !hasReservedField(eventType, schemaAsJson, field))
.collect(Collectors.toList());
if (!absentFields.isEmpty()) {
throw new InvalidEventTypeException("partition_key_fields " + absentFields + " absent in schema");
}
} catch (final JSONException e) {
throw new InvalidEventTypeException("schema must be a valid json");
} catch (final SchemaException e) {
throw new InvalidEventTypeException("schema must be a valid json-schema");
}
}
private void validateSchema(final EventType eventType) throws InvalidEventTypeException {
try {
final JSONObject schemaAsJson = new JSONObject(eventType.getSchema().getSchema());
if (hasReservedField(eventType, schemaAsJson, "metadata")) {
throw new InvalidEventTypeException("\"metadata\" property is reserved");
}
validatePartitionKeys(eventType);
SchemaLoader.load(schemaAsJson);
} catch (final JSONException e) {
throw new InvalidEventTypeException("schema must be a valid json");
} catch (final SchemaException e) {
throw new InvalidEventTypeException("schema must be a valid json-schema");
}
}
private void assignTopic(final EventType eventType) {
eventType.setTopic(uuidGenerator.randomUUID().toString());
}
private boolean hasReservedField(final EventType eventType, final JSONObject schemaAsJson, final String field) {
return eventType.getCategory() == EventCategory.BUSINESS
&& schemaAsJson.optJSONObject("properties") != null
&& schemaAsJson.getJSONObject("properties").has(field);
}
private void validateUpdate(final String name, final EventType eventType) throws NoSuchEventTypeException,
InternalNakadiException, InvalidEventTypeException, NoSuchPartitionStrategyException {
final EventType existingEventType = eventTypeRepository.findByName(name);
validateName(name, eventType);
validatePartitionKeys(eventType);
validateSchemaChange(eventType, existingEventType);
eventType.setDefaultStatistics(
validateStatisticsUpdate(existingEventType.getDefaultStatistics(), eventType.getDefaultStatistics()));
}
private EventTypeStatistics validateStatisticsUpdate(final EventTypeStatistics existing, final EventTypeStatistics newStatistics) throws InvalidEventTypeException {
if (existing != null && newStatistics == null) {
return existing;
}
if (!Objects.equals(existing, newStatistics)) {
throw new InvalidEventTypeException("default statistics must not be changed");
}
return newStatistics;
}
private void validateName(final String name, final EventType eventType) throws InvalidEventTypeException {
if (!eventType.getName().equals(name)) {
throw new InvalidEventTypeException("path does not match resource name");
}
}
private void validateSchemaChange(final EventType eventType, final EventType existingEventType) throws InvalidEventTypeException {
if (!existingEventType.getSchema().equals(eventType.getSchema())) {
throw new InvalidEventTypeException("schema must not be changed");
=======
public ResponseEntity<?> get(@PathVariable final String name, final NativeWebRequest request) {
final Result<EventType> result = eventTypeService.get(name);
if (!result.isSuccessful()) {
return Responses.create(result.getProblem(), request);
>>>>>>>
public ResponseEntity<?> get(@PathVariable final String name, final NativeWebRequest request) {
final Result<EventType> result = eventTypeService.get(name);
if (!result.isSuccessful()) {
return Responses.create(result.getProblem(), request); |
<<<<<<<
import org.zalando.nakadi.exceptions.runtime.InternalNakadiException;
=======
import org.zalando.nakadi.exceptions.runtime.DbWriteOperationsBlockedException;
import org.zalando.nakadi.exceptions.runtime.DuplicatedStorageException;
import org.zalando.nakadi.exceptions.runtime.InternalNakadiException;
import org.zalando.nakadi.exceptions.runtime.NoSuchStorageException;
import org.zalando.nakadi.exceptions.runtime.StorageIsUsedException;
import org.zalando.nakadi.exceptions.runtime.UnknownStorageTypeException;
import org.zalando.nakadi.plugin.api.PluginException;
>>>>>>>
import org.zalando.nakadi.exceptions.runtime.InternalNakadiException;
<<<<<<<
=======
private static final Logger LOG = LoggerFactory.getLogger(StoragesController.class);
private final SecuritySettings securitySettings;
>>>>>>>
<<<<<<<
public ResponseEntity<?> listStorages(final NativeWebRequest request) throws InternalNakadiException {
=======
public ResponseEntity<?> listStorages(final NativeWebRequest request)
throws InternalNakadiException, PluginException {
>>>>>>>
public ResponseEntity<?> listStorages(final NativeWebRequest request)
throws InternalNakadiException, PluginException {
<<<<<<<
final Storage storage = storageService.setDefaultStorage(id);
return status(OK).body(storage);
=======
final Storage storage = storageService.setDefaultStorage(id);
return status(OK).body(storage);
}
@ExceptionHandler(NoSuchStorageException.class)
public ResponseEntity<Problem> handleNoSuchStorageException(
final NoSuchStorageException exception,
final NativeWebRequest request) {
LOG.debug(exception.getMessage());
return Responses.create(NOT_FOUND, exception.getMessage(), request);
}
@ExceptionHandler(StorageIsUsedException.class)
public ResponseEntity<Problem> handleStorageIsUsedException(
final StorageIsUsedException exception,
final NativeWebRequest request) {
LOG.debug(exception.getMessage());
return Responses.create(Response.Status.FORBIDDEN, exception.getMessage(), request);
}
@ExceptionHandler(DuplicatedStorageException.class)
public ResponseEntity<Problem> handleDuplicatedStorageException(
final DuplicatedStorageException exception,
final NativeWebRequest request) {
LOG.debug(exception.getMessage());
return Responses.create(CONFLICT, exception.getMessage(), request);
}
@ExceptionHandler(UnknownStorageTypeException.class)
public ResponseEntity<Problem> handleUnknownStorageTypeException(
final UnknownStorageTypeException exception,
final NativeWebRequest request) {
LOG.debug(exception.getMessage());
return Responses.create(UNPROCESSABLE_ENTITY, exception.getMessage(), request);
>>>>>>>
final Storage storage = storageService.setDefaultStorage(id);
return status(OK).body(storage); |
<<<<<<<
import org.zalando.nakadi.partitioning.PartitionStrategy;
=======
import org.zalando.nakadi.exceptions.NoSuchEventTypeException;
>>>>>>>
import org.zalando.nakadi.partitioning.PartitionStrategy;
import org.zalando.nakadi.exceptions.NoSuchEventTypeException;
<<<<<<<
import java.util.Collections;
=======
import java.util.List;
>>>>>>>
import java.util.List;
import java.util.Collections; |
<<<<<<<
=======
import com.fasterxml.jackson.databind.ObjectMapper;
import org.json.JSONObject;
import org.junit.Before;
import org.junit.Test;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.test.web.servlet.MockMvc;
import org.zalando.nakadi.config.JsonConfig;
import org.zalando.nakadi.config.SecuritySettings;
import org.zalando.nakadi.domain.Storage;
import org.zalando.nakadi.security.ClientResolver;
import org.zalando.nakadi.service.Result;
import org.zalando.nakadi.service.StorageService;
import org.zalando.nakadi.util.FeatureToggleService;
import org.zalando.problem.Problem;
>>>>>>>
import org.json.JSONObject;
import org.junit.Before;
import org.junit.Test;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.test.web.servlet.MockMvc;
import org.zalando.nakadi.config.SecuritySettings;
import org.zalando.nakadi.domain.Storage;
import org.zalando.nakadi.security.ClientResolver;
import org.zalando.nakadi.service.Result;
import org.zalando.nakadi.service.StorageService;
import org.zalando.nakadi.util.FeatureToggleService;
import org.zalando.nakadi.utils.TestUtils;
import org.zalando.problem.Problem;
<<<<<<<
.setMessageConverters(new StringHttpMessageConverter(), TestUtils.JACKSON_2_HTTP_MESSAGE_CONVERTER)
.setCustomArgumentResolvers(new ClientResolver(securitySettings))
=======
.setMessageConverters(new StringHttpMessageConverter(),
new MappingJackson2HttpMessageConverter(objectMapper))
.setCustomArgumentResolvers(new ClientResolver(securitySettings, featureToggleService))
>>>>>>>
.setMessageConverters(new StringHttpMessageConverter(), TestUtils.JACKSON_2_HTTP_MESSAGE_CONVERTER)
.setCustomArgumentResolvers(new ClientResolver(securitySettings, featureToggleService)) |
<<<<<<<
public EventTypeValidator getValidator(final String name) throws ExecutionException {
return validatorCache.get(name);
}
public void created(final EventType eventType) throws Exception {
final String path = getZNodePath(eventType.getName());
zkClient
.create()
.creatingParentsIfNeeded()
.withMode(CreateMode.PERSISTENT)
.forPath(path, new byte[0]);
=======
public void created(final String name) throws Exception {
try {
final String path = getZNodePath(name);
zkClient
.create()
.creatingParentsIfNeeded()
.withMode(CreateMode.PERSISTENT)
.forPath(path, new byte[0]);
} catch (KeeperException.NodeExistsException e) {
// silently do nothing since it's already been tracked
}
>>>>>>>
public EventTypeValidator getValidator(final String name) throws ExecutionException {
return validatorCache.get(name);
}
public void created(final String name) throws Exception {
try {
final String path = getZNodePath(name);
zkClient
.create()
.creatingParentsIfNeeded()
.withMode(CreateMode.PERSISTENT)
.forPath(path, new byte[0]);
} catch (KeeperException.NodeExistsException e) {
// silently do nothing since it's already been tracked
} |
<<<<<<<
eventTypeRepository, timelineService, objectMapper, eventStreamFactoryMock, metricRegistry, crutch,
blacklistService, consumerLimitingService, featureToggleService);
=======
eventTypeRepository, topicRepositoryMock, objectMapper, eventStreamFactoryMock, metricRegistry, crutch,
blacklistService, consumerLimitingService, featureToggleService,
new CursorConverter(featureToggleService));
>>>>>>>
eventTypeRepository, timelineService, objectMapper, eventStreamFactoryMock, metricRegistry, crutch,
blacklistService, consumerLimitingService, featureToggleService,
new CursorConverter(featureToggleService)); |
<<<<<<<
import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import java.util.stream.Stream;
=======
>>>>>>>
<<<<<<<
import static org.zalando.nakadi.webservice.utils.NakadiTestUtils.publishEvents;
import org.zalando.nakadi.webservice.utils.TestStreamingClient;
=======
import static org.zalando.nakadi.webservice.utils.NakadiTestUtils.publishEvent;
>>>>>>>
import static org.zalando.nakadi.webservice.utils.NakadiTestUtils.publishEvents; |
<<<<<<<
etc.created(et);
etc.getEventType(et.getName());
=======
etc.created(et.getName());
etc.get(et.getName());
>>>>>>>
etc.created(et.getName());
etc.getEventType(et.getName());
<<<<<<<
} catch (NoSuchEventTypeException e) {
fail();
=======
>>>>>>>
} catch (NoSuchEventTypeException e) {
fail(); |
<<<<<<<
=======
import org.zalando.nakadi.domain.EventType;
import org.zalando.nakadi.domain.EventTypeOptions;
import org.zalando.nakadi.problem.ValidationProblem;
import org.zalando.nakadi.config.NakadiSettings;
import org.zalando.nakadi.security.Client;
import org.zalando.nakadi.service.EventTypeService;
import org.zalando.nakadi.service.Result;
import org.zalando.nakadi.util.FeatureToggleService;
import org.zalando.nakadi.validation.EventTypeOptionsValidator;
>>>>>>>
<<<<<<<
private final ApplicationService applicationService;
=======
private final NakadiSettings nakadiSettings;
>>>>>>>
private final ApplicationService applicationService;
private final NakadiSettings nakadiSettings;
<<<<<<<
final EventTypeOptionsValidator eventTypeOptionsValidator,
final ApplicationService applicationService) {
=======
final EventTypeOptionsValidator eventTypeOptionsValidator,
final NakadiSettings nakadiSettings) {
>>>>>>>
final EventTypeOptionsValidator eventTypeOptionsValidator,
final ApplicationService applicationService,
final NakadiSettings nakadiSettings) {
<<<<<<<
this.applicationService = applicationService;
=======
this.nakadiSettings = nakadiSettings;
>>>>>>>
this.applicationService = applicationService;
this.nakadiSettings = nakadiSettings; |
<<<<<<<
import org.springframework.core.task.SimpleAsyncTaskExecutor;
import org.springframework.core.task.TaskExecutor;
import org.springframework.web.WebApplicationInitializer;
=======
import org.springframework.context.annotation.Primary;
>>>>>>>
import org.springframework.context.annotation.Primary;
import org.springframework.core.task.SimpleAsyncTaskExecutor;
import org.springframework.core.task.TaskExecutor;
import org.springframework.web.WebApplicationInitializer; |
<<<<<<<
.setMessageConverters(new StringHttpMessageConverter(), TestUtils.JACKSON_2_HTTP_MESSAGE_CONVERTER)
.setCustomArgumentResolvers(new ClientResolver(securitySettings))
=======
.setMessageConverters(new StringHttpMessageConverter(),
new MappingJackson2HttpMessageConverter(objectMapper))
.setCustomArgumentResolvers(new ClientResolver(securitySettings, featureToggleService))
>>>>>>>
.setMessageConverters(new StringHttpMessageConverter(), TestUtils.JACKSON_2_HTTP_MESSAGE_CONVERTER)
.setCustomArgumentResolvers(new ClientResolver(securitySettings, featureToggleService)) |
<<<<<<<
import de.zalando.aruha.nakadi.domain.EventType;
=======
import de.zalando.aruha.nakadi.domain.EventType;
import de.zalando.aruha.nakadi.domain.ValidationStrategyConfiguration;
>>>>>>>
import de.zalando.aruha.nakadi.domain.EventType;
import de.zalando.aruha.nakadi.domain.EventType;
import de.zalando.aruha.nakadi.domain.ValidationStrategyConfiguration;
<<<<<<<
private final PartitioningStrategy orderingKeyFieldsPartitioningStrategy = new OrderingKeyFieldsPartitioningStrategy();
=======
private final ValidationStrategy validationStrategy = new EventBodyMustRespectSchema();
private final ValidationStrategyConfiguration vsc = new ValidationStrategyConfiguration();
>>>>>>>
private final PartitioningStrategy orderingKeyFieldsPartitioningStrategy = new OrderingKeyFieldsPartitioningStrategy();
private final ValidationStrategy validationStrategy = new EventBodyMustRespectSchema();
private final ValidationStrategyConfiguration vsc = new ValidationStrategyConfiguration();
<<<<<<<
final EventType eventType = eventTypeRepository.findByName(eventTypeName);
String partitionId;
if (!eventType.getOrderingKeyFields().isEmpty()) {
partitionId = orderingKeyFieldsPartitioningStrategy.calculatePartition(eventType, event, 8);
} else {
// Will be replaced later:
partitionId = "1";
}
topicRepository.postEvent(eventTypeName, partitionId, event);
return status(HttpStatus.CREATED).build();
=======
final EventType eventType = eventTypeRepository.findByName(eventTypeName);
final Optional<ValidationError> error = validateSchema(event, eventType);
if (error.isPresent()) {
final Problem p = Problem.valueOf(MoreStatus.UNPROCESSABLE_ENTITY, error.get().getMessage());
return create(p, nativeWebRequest);
} else {
// Will be replaced later:
final String partitionId = "1";
topicRepository.postEvent(eventTypeName, partitionId, event);
return status(HttpStatus.CREATED).build();
}
>>>>>>>
final EventType eventType = eventTypeRepository.findByName(eventTypeName);
final Optional<ValidationError> error = validateSchema(event, eventType);
if (error.isPresent()) {
final Problem p = Problem.valueOf(MoreStatus.UNPROCESSABLE_ENTITY, error.get().getMessage());
return create(p, nativeWebRequest);
} else {
String partitionId;
if (!eventType.getOrderingKeyFields().isEmpty()) {
partitionId = orderingKeyFieldsPartitioningStrategy.calculatePartition(eventType, event, 8);
} else {
// Will be replaced later:
partitionId = "1";
}
topicRepository.postEvent(eventTypeName, partitionId, event);
return status(HttpStatus.CREATED).build();
} |
<<<<<<<
import javax.ws.rs.core.Response;
import static javax.ws.rs.core.Response.Status.FORBIDDEN;
=======
>>>>>>>
import javax.ws.rs.core.Response;
import static javax.ws.rs.core.Response.Status.FORBIDDEN;
<<<<<<<
import org.zalando.nakadi.domain.EventType;
import org.zalando.nakadi.domain.EventTypeAuthorization;
import org.zalando.nakadi.domain.EventTypeAuthorizationAttribute;
import org.zalando.nakadi.domain.EventTypeBase;
import org.zalando.nakadi.domain.EventTypeOptions;
import org.zalando.nakadi.domain.Subscription;
import org.zalando.nakadi.domain.Timeline;
import org.zalando.nakadi.exceptions.DuplicatedEventTypeNameException;
import org.zalando.nakadi.exceptions.InternalNakadiException;
import org.zalando.nakadi.exceptions.InvalidEventTypeException;
import org.zalando.nakadi.exceptions.NoSuchEventTypeException;
import org.zalando.nakadi.exceptions.TopicCreationException;
import org.zalando.nakadi.exceptions.TopicDeletionException;
import org.zalando.nakadi.exceptions.UnableProcessException;
import org.zalando.nakadi.exceptions.UnprocessableEntityException;
import org.zalando.nakadi.exceptions.runtime.TopicConfigException;
import org.zalando.nakadi.partitioning.PartitionStrategy;
import org.zalando.nakadi.repository.TopicRepository;
import static org.zalando.nakadi.util.FeatureToggleService.Feature.CHECK_APPLICATION_LEVEL_PERMISSIONS;
import org.zalando.nakadi.utils.EventTypeTestBuilder;
import org.zalando.nakadi.utils.TestUtils;
=======
>>>>>>>
import org.zalando.nakadi.domain.EventType;
import org.zalando.nakadi.domain.EventTypeAuthorization;
import org.zalando.nakadi.domain.EventTypeAuthorizationAttribute;
import org.zalando.nakadi.domain.EventTypeBase;
import org.zalando.nakadi.domain.EventTypeOptions;
import org.zalando.nakadi.domain.Subscription;
import org.zalando.nakadi.domain.Timeline;
import org.zalando.nakadi.exceptions.DuplicatedEventTypeNameException;
import org.zalando.nakadi.exceptions.InternalNakadiException;
import org.zalando.nakadi.exceptions.InvalidEventTypeException;
import org.zalando.nakadi.exceptions.NoSuchEventTypeException;
import org.zalando.nakadi.exceptions.TopicCreationException;
import org.zalando.nakadi.exceptions.TopicDeletionException;
import org.zalando.nakadi.exceptions.UnableProcessException;
import org.zalando.nakadi.exceptions.UnprocessableEntityException;
import org.zalando.nakadi.exceptions.runtime.TopicConfigException;
import org.zalando.nakadi.partitioning.PartitionStrategy;
import org.zalando.nakadi.repository.TopicRepository;
import static org.zalando.nakadi.util.FeatureToggleService.Feature.CHECK_APPLICATION_LEVEL_PERMISSIONS;
import org.zalando.nakadi.utils.EventTypeTestBuilder;
import org.zalando.nakadi.utils.TestUtils; |
<<<<<<<
protected final AuthorizationService authorizationService = mock(AuthorizationService.class);
=======
protected final NakadiAuditLogPublisher nakadiAuditLogPublisher = mock(NakadiAuditLogPublisher.class);
>>>>>>>
protected final AuthorizationService authorizationService = mock(AuthorizationService.class);
protected final NakadiAuditLogPublisher nakadiAuditLogPublisher = mock(NakadiAuditLogPublisher.class); |
<<<<<<<
private Optional<Set<String>> writeScope;
private Optional<Set<String>> readScope;
=======
public EventType() {}
public EventType(final String name, final String topic, final String owningApplication, final EventCategory category,
final List<ValidationStrategyConfiguration> validationStrategies,
final List<EnrichmentStrategyDescriptor> enrichmentStrategies, final String partitionStrategy,
final List<String> partitionKeyFields, final EventTypeSchema schema, final EventTypeStatistics defaultStatistic,
final EventTypeOptions options)
{
this.name = name;
this.topic = topic;
this.owningApplication = owningApplication;
this.category = category;
this.validationStrategies = validationStrategies;
this.enrichmentStrategies = enrichmentStrategies;
this.partitionStrategy = partitionStrategy;
this.partitionKeyFields = partitionKeyFields;
this.schema = schema;
this.defaultStatistic = defaultStatistic;
this.options = options;
}
>>>>>>>
private Optional<Set<String>> writeScope;
private Optional<Set<String>> readScope;
public EventType() {}
public EventType(final String name, final String topic, final String owningApplication, final EventCategory category,
final List<ValidationStrategyConfiguration> validationStrategies,
final List<EnrichmentStrategyDescriptor> enrichmentStrategies, final String partitionStrategy,
final List<String> partitionKeyFields, final EventTypeSchema schema, final EventTypeStatistics defaultStatistic,
final EventTypeOptions options)
{
this.name = name;
this.topic = topic;
this.owningApplication = owningApplication;
this.category = category;
this.validationStrategies = validationStrategies;
this.enrichmentStrategies = enrichmentStrategies;
this.partitionStrategy = partitionStrategy;
this.partitionKeyFields = partitionKeyFields;
this.schema = schema;
this.defaultStatistic = defaultStatistic;
this.options = options;
} |
<<<<<<<
import org.zalando.nakadi.domain.Timeline;
=======
>>>>>>>
import org.zalando.nakadi.domain.Timeline;
<<<<<<<
import org.zalando.nakadi.service.timeline.TimelineService;
import org.zalando.nakadi.view.SubscriptionCursor;
=======
import org.zalando.nakadi.util.FeatureToggleService;
import org.zalando.nakadi.view.SubscriptionCursor;
>>>>>>>
import org.zalando.nakadi.service.timeline.TimelineService;
import org.zalando.nakadi.util.FeatureToggleService;
import org.zalando.nakadi.view.SubscriptionCursor;
<<<<<<<
cursorsService = new CursorsService(zkHolder, timelineService, subscriptionRepo, eventTypeRepository,
tokenService);
=======
final FeatureToggleService featureToggleService = mock(FeatureToggleService.class);
when(featureToggleService.isFeatureEnabled(eq(FeatureToggleService.Feature.ZERO_PADDED_OFFSETS)))
.thenReturn(Boolean.TRUE);
cursorsService = new CursorsService(zkHolder, topicRepository, subscriptionRepo, eventTypeRepository,
tokenService, new CursorConverter(featureToggleService));
>>>>>>>
final FeatureToggleService featureToggleService = mock(FeatureToggleService.class);
when(featureToggleService.isFeatureEnabled(eq(FeatureToggleService.Feature.ZERO_PADDED_OFFSETS)))
.thenReturn(Boolean.TRUE);
cursorsService = new CursorsService(zkHolder, timelineService, subscriptionRepo, eventTypeRepository,
tokenService, new CursorConverter(featureToggleService)); |
<<<<<<<
import org.zalando.nakadi.domain.SubscriptionBase;
import org.zalando.nakadi.exceptions.InternalNakadiException;
=======
import org.zalando.nakadi.domain.EventTypeResource;
import org.zalando.nakadi.exceptions.ForbiddenAccessException;
>>>>>>>
import org.zalando.nakadi.domain.EventTypeResource;
import org.zalando.nakadi.domain.SubscriptionBase;
import org.zalando.nakadi.exceptions.ForbiddenAccessException;
import org.zalando.nakadi.exceptions.InternalNakadiException;
<<<<<<<
import org.zalando.nakadi.exceptions.runtime.AccessDeniedException;
import org.zalando.nakadi.exceptions.runtime.ServiceTemporaryUnavailableException;
=======
import org.zalando.nakadi.exceptions.runtime.ServiceTemporarilyUnavailableException;
>>>>>>>
import org.zalando.nakadi.exceptions.runtime.AccessDeniedException;
import org.zalando.nakadi.exceptions.runtime.ServiceTemporarilyUnavailableException;
<<<<<<<
import org.zalando.nakadi.plugin.api.authz.Resource;
import org.zalando.nakadi.plugin.api.authz.Subject;
import org.zalando.nakadi.repository.EventTypeRepository;
import org.zalando.nakadi.security.Client;
import javax.annotation.Nullable;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import static com.google.common.collect.Lists.newArrayList;
import static com.google.common.collect.Sets.newHashSet;
=======
import org.zalando.nakadi.plugin.api.authz.Resource;
>>>>>>>
import org.zalando.nakadi.plugin.api.authz.Resource;
import org.zalando.nakadi.plugin.api.authz.Subject;
import org.zalando.nakadi.repository.EventTypeRepository;
import org.zalando.nakadi.security.Client;
import javax.annotation.Nullable;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import static com.google.common.collect.Lists.newArrayList;
import static com.google.common.collect.Sets.newHashSet; |
<<<<<<<
// Updates should eventually cause a cache invalidation, so we must retry
executeWithRetry(() -> {
// get event type to check that update is done
jsonRequestSpec()
.when()
.get("/event-types/" + TEST_EVENT_TYPE)
.then()
.statusCode(OK.value())
.and()
.body("owning_application", equalTo("my-app"))
.body("category", equalTo("new-data"));
},
new RetryForSpecifiedTimeStrategy<Void>(5000).withExceptionsThatForceRetry(AssertionError.class)
.withWaitBetweenEachTry(500));
=======
// get event type to check that update is done
jsonRequestSpec()
.when()
.get("/event-types/" + TEST_EVENT_TYPE)
.then()
.statusCode(OK.value())
.and()
.body("owning_application", equalTo("my-app"))
.body("category", equalTo("business"));
>>>>>>>
// Updates should eventually cause a cache invalidation, so we must retry
executeWithRetry(() -> {
// get event type to check that update is done
jsonRequestSpec()
.when()
.get("/event-types/" + TEST_EVENT_TYPE)
.then()
.statusCode(OK.value())
.and()
.body("owning_application", equalTo("my-app"))
.body("category", equalTo("business"));
},
new RetryForSpecifiedTimeStrategy<Void>(5000).withExceptionsThatForceRetry(AssertionError.class)
.withWaitBetweenEachTry(500)); |
<<<<<<<
import org.mockito.ArgumentCaptor;
=======
import org.junit.rules.ExpectedException;
>>>>>>>
import org.mockito.ArgumentCaptor;
import org.junit.rules.ExpectedException; |
<<<<<<<
import de.zalando.aruha.nakadi.util.FeatureToggleService;
=======
import de.zalando.aruha.nakadi.util.UUIDGenerator;
>>>>>>>
import de.zalando.aruha.nakadi.util.FeatureToggleService;
import de.zalando.aruha.nakadi.util.UUIDGenerator;
<<<<<<<
partitionResolver, enrichment, featureToggleService);
=======
partitionResolver, enrichment, uuid);
Mockito.doReturn(randomUUID).when(uuid).randomUUID();
>>>>>>>
partitionResolver, enrichment, featureToggleService, uuid);
Mockito.doReturn(randomUUID).when(uuid).randomUUID(); |
<<<<<<<
import org.zalando.nakadi.util.JsonUtils;
import org.zalando.nakadi.util.UUIDGenerator;
=======
>>>>>>>
import org.zalando.nakadi.util.JsonUtils;
import org.zalando.nakadi.util.UUIDGenerator;
<<<<<<<
private EventTypeStatistics validateStatisticsUpdate(final EventTypeStatistics existing,
final EventTypeStatistics newStatistics)
throws InvalidEventTypeException {
=======
private EventTypeStatistics validateStatisticsUpdate(
final EventTypeStatistics existing,
final EventTypeStatistics newStatistics) throws InvalidEventTypeException {
>>>>>>>
private EventTypeStatistics validateStatisticsUpdate(
final EventTypeStatistics existing,
final EventTypeStatistics newStatistics) throws InvalidEventTypeException { |
<<<<<<<
=======
private void initListeners() {
// set the text for the currency button
if(isColu) {
if (_amount == null) {
_amount = Value.valueOf(_account.getCoinType(), 0);
}
} else {
// btCurrency.setText(_mbwManager.getBitcoinDenomination().getUnicodeName());
btCurrency.setEnabled(_mbwManager.getCurrencySwitcher().getExchangeRatePrice() != null);
}
}
>>>>>>>
<<<<<<<
_amount = _mbwManager.getExchangeRateManager().get(_amount, targetCurrency);
=======
// _amount = CurrencyValue.fromValue(_amount, targetCurrency, _mbwManager.getExchangeRateManager());
_amount = Value.valueOf(targetCurrency, _mbwManager.getExchangeRateManager().get(_amount, targetCurrency).value);
// todo create a FiatValue for _amount?
>>>>>>>
_amount = _mbwManager.getExchangeRateManager().get(_amount, targetCurrency);
<<<<<<<
Address address = Address.getNullAddress(_mbwManager.getNetwork());
SendRequest<?> sendRequest = _account.getSendToRequest(AddressUtils.fromAddress(address), value, Value.valueOf(_account.getCoinType(), _kbMinerFee));
=======
SendRequest<?> sendRequest = _account.getSendToRequest(_account.getDummyAddress(destinationAddress.getSubType()), Value.valueOf(_account.getCoinType(), satoshis), Value.valueOf(_account.getCoinType(), _kbMinerFee));
>>>>>>>
SendRequest<?> sendRequest = _account.getSendToRequest(_account.getDummyAddress(destinationAddress.getSubType()), value, Value.valueOf(_account.getCoinType(), _kbMinerFee)); |
<<<<<<<
=======
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.PartitionInfo;
import org.hamcrest.Matchers;
import org.junit.Before;
import org.junit.Test;
import org.springframework.http.HttpStatus;
import org.zalando.nakadi.domain.EventType;
import org.zalando.nakadi.repository.kafka.KafkaTestHelper;
import org.zalando.nakadi.view.Cursor;
import org.zalando.nakadi.webservice.utils.NakadiTestUtils;
>>>>>>>
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.PartitionInfo;
import org.hamcrest.Matchers;
import org.junit.Before;
import org.junit.Test;
import org.springframework.http.HttpStatus;
import org.zalando.nakadi.domain.EventType;
import org.zalando.nakadi.repository.kafka.KafkaTestHelper;
import org.zalando.nakadi.view.Cursor;
import org.zalando.nakadi.webservice.utils.NakadiTestUtils;
<<<<<<<
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.PartitionInfo;
=======
import static com.jayway.restassured.RestAssured.get;
import static com.jayway.restassured.RestAssured.when;
>>>>>>>
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.PartitionInfo;
import static com.jayway.restassured.RestAssured.get;
import static com.jayway.restassured.RestAssured.when; |
<<<<<<<
import static com.jayway.restassured.RestAssured.given;
import static com.jayway.restassured.RestAssured.when;
import static com.jayway.restassured.http.ContentType.JSON;
import java.io.IOException;
import static java.text.MessageFormat.format;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import static java.util.stream.IntStream.range;
import static java.util.stream.IntStream.rangeClosed;
import org.apache.http.HttpStatus;
import static org.apache.http.HttpStatus.SC_CONFLICT;
import static org.apache.http.HttpStatus.SC_NO_CONTENT;
import static org.apache.http.HttpStatus.SC_OK;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.empty;
import static org.hamcrest.Matchers.hasSize;
import static org.hamcrest.Matchers.not;
import org.hamcrest.core.StringContains;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.zalando.nakadi.config.JsonConfig;
import org.zalando.nakadi.domain.EventType;
import org.zalando.nakadi.domain.ItemsWrapper;
import org.zalando.nakadi.domain.Subscription;
import org.zalando.nakadi.domain.SubscriptionBase;
import static org.zalando.nakadi.domain.SubscriptionBase.InitialPosition.BEGIN;
import static org.zalando.nakadi.domain.SubscriptionBase.InitialPosition.END;
import org.zalando.nakadi.domain.SubscriptionEventTypeStats;
import org.zalando.nakadi.service.BlacklistService;
import org.zalando.nakadi.utils.JsonTestHelper;
import org.zalando.nakadi.utils.RandomSubscriptionBuilder;
import static org.zalando.nakadi.utils.TestUtils.waitFor;
import org.zalando.nakadi.view.Cursor;
import org.zalando.nakadi.view.SubscriptionCursor;
import org.zalando.nakadi.webservice.BaseAT;
import org.zalando.nakadi.webservice.SettingsControllerAT;
=======
import com.google.common.collect.Sets;
import static com.jayway.restassured.RestAssured.given;
import static com.jayway.restassured.RestAssured.when;
import static com.jayway.restassured.http.ContentType.JSON;
import java.io.IOException;
import static java.text.MessageFormat.format;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import org.apache.http.HttpStatus;
import static org.apache.http.HttpStatus.SC_CONFLICT;
import static org.apache.http.HttpStatus.SC_NO_CONTENT;
import static org.apache.http.HttpStatus.SC_OK;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.empty;
import static org.hamcrest.Matchers.hasSize;
import static org.hamcrest.Matchers.not;
import org.hamcrest.core.StringContains;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.zalando.nakadi.config.JsonConfig;
import org.zalando.nakadi.domain.EventType;
import org.zalando.nakadi.domain.ItemsWrapper;
import org.zalando.nakadi.domain.Subscription;
import org.zalando.nakadi.domain.SubscriptionBase;
import static org.zalando.nakadi.domain.SubscriptionBase.InitialPosition.BEGIN;
import static org.zalando.nakadi.domain.SubscriptionBase.InitialPosition.END;
import org.zalando.nakadi.domain.SubscriptionEventTypeStats;
import org.zalando.nakadi.service.BlacklistService;
import org.zalando.nakadi.utils.JsonTestHelper;
import org.zalando.nakadi.utils.RandomSubscriptionBuilder;
import static org.zalando.nakadi.utils.TestUtils.waitFor;
import org.zalando.nakadi.view.Cursor;
import org.zalando.nakadi.view.SubscriptionCursor;
import org.zalando.nakadi.webservice.BaseAT;
import org.zalando.nakadi.webservice.SettingsControllerAT;
>>>>>>>
import org.apache.http.HttpStatus;
import org.hamcrest.core.StringContains;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.zalando.nakadi.config.JsonConfig;
import org.zalando.nakadi.domain.EventType;
import org.zalando.nakadi.domain.ItemsWrapper;
import org.zalando.nakadi.domain.Subscription;
import org.zalando.nakadi.domain.SubscriptionBase;
import org.zalando.nakadi.domain.SubscriptionEventTypeStats;
import org.zalando.nakadi.service.BlacklistService;
import org.zalando.nakadi.utils.JsonTestHelper;
import org.zalando.nakadi.utils.RandomSubscriptionBuilder;
import org.zalando.nakadi.view.Cursor;
import org.zalando.nakadi.view.SubscriptionCursor;
import org.zalando.nakadi.webservice.BaseAT;
import org.zalando.nakadi.webservice.SettingsControllerAT;
import org.zalando.nakadi.webservice.utils.NakadiTestUtils;
import org.zalando.nakadi.webservice.utils.TestStreamingClient;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import static com.jayway.restassured.RestAssured.given;
import static com.jayway.restassured.RestAssured.when;
import static com.jayway.restassured.http.ContentType.JSON;
import static java.text.MessageFormat.format;
import static org.apache.http.HttpStatus.SC_CONFLICT;
import static org.apache.http.HttpStatus.SC_NO_CONTENT;
import static org.apache.http.HttpStatus.SC_OK;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.empty;
import static org.hamcrest.Matchers.hasSize;
import static org.hamcrest.Matchers.not;
import static org.zalando.nakadi.domain.SubscriptionBase.InitialPosition.BEGIN;
import static org.zalando.nakadi.domain.SubscriptionBase.InitialPosition.END;
import static org.zalando.nakadi.utils.TestUtils.waitFor;
<<<<<<<
import org.zalando.nakadi.webservice.utils.TestStreamingClient;
=======
import static org.zalando.nakadi.webservice.utils.NakadiTestUtils.publishEvents;
import org.zalando.nakadi.webservice.utils.TestStreamingClient;
>>>>>>>
import static org.zalando.nakadi.webservice.utils.NakadiTestUtils.publishEvents; |
<<<<<<<
import static java.util.Optional.empty;
import java.util.UUID;
=======
>>>>>>>
import static java.util.Optional.empty;
import java.util.UUID;
<<<<<<<
import org.zalando.nakadi.domain.ConsumedEvent;
import org.zalando.nakadi.domain.NakadiCursor;
import org.zalando.nakadi.domain.Timeline;
import org.zalando.nakadi.exceptions.NakadiException;
import org.zalando.nakadi.exceptions.runtime.AccessDeniedException;
import org.zalando.nakadi.repository.db.EventTypeCache;
import org.zalando.nakadi.repository.kafka.KafkaCursor;
import org.zalando.nakadi.repository.kafka.NakadiKafkaConsumer;
=======
>>>>>>>
import org.zalando.nakadi.domain.ConsumedEvent;
import org.zalando.nakadi.domain.NakadiCursor;
import org.zalando.nakadi.domain.Timeline;
import org.zalando.nakadi.exceptions.NakadiException;
import org.zalando.nakadi.exceptions.runtime.AccessDeniedException;
import org.zalando.nakadi.repository.db.EventTypeCache;
import org.zalando.nakadi.repository.kafka.KafkaCursor;
import org.zalando.nakadi.repository.kafka.NakadiKafkaConsumer;
<<<<<<<
import org.zalando.nakadi.service.converter.CursorConverterImpl;
import org.zalando.nakadi.service.timeline.TimelineService;
import org.zalando.nakadi.utils.TestUtils;
=======
>>>>>>>
import org.zalando.nakadi.service.converter.CursorConverterImpl;
import org.zalando.nakadi.service.timeline.TimelineService;
import org.zalando.nakadi.utils.TestUtils; |
<<<<<<<
import static javax.ws.rs.core.Response.Status.CONFLICT;
import static org.hamcrest.CoreMatchers.not;
=======
>>>>>>> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.