apache / incubator-omid / 66

pending completion

Build # 66

Build Type

push

travis-ci

Committed by

ohadshacham

Commit Message

<a href="https://github.com/apache/incubator-omid/commit/f6f548a57">[OMID-62] Use interface instead of TSOClient in AbstractTransactionManager

This will make it easy to mock AbstractTransactionManager dependencies

This closes #9

Change-Id: I</a><a class="double-link" href="https://github.com/apache/incubator-omid/commit/a3c0d5926">a3c0d5926</a>

Run Details

8 of 8 new or added lines in 3 files covered. (100.0%)

2227 of 4083 relevant lines covered (54.54%)

709676.65 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

78.0

/transaction-client/src/main/java/org/apache/omid/tso/client/MockTSOClient.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.omid.tso.client;

import com.google.common.util.concurrent.SettableFuture;
import org.apache.omid.committable.CommitTable;

import java.io.IOException;
import java.util.Set;
import java.util.concurrent.atomic.AtomicLong;

// TODO Would be nice to compile all util classes for testing to a separate package that clients could import for tests
public class MockTSOClient implements TSOProtocol {

    private static final int CONFLICT_MAP_SIZE = 1_000_000;

    private final AtomicLong timestampGenerator = new AtomicLong();
    private final long[] conflictMap = new long[CONFLICT_MAP_SIZE];
    private final AtomicLong lwm = new AtomicLong();

    private final CommitTable.Writer commitTable;

    public MockTSOClient(CommitTable.Writer commitTable) {
        this.commitTable = commitTable;
    }

    @Override
    public TSOFuture<Long> getNewStartTimestamp() {
        synchronized (conflictMap) {
            SettableFuture<Long> f = SettableFuture.create();
            f.set(timestampGenerator.incrementAndGet());
            return new ForwardingTSOFuture<>(f);
        }
    }

    @Override
    public TSOFuture<Long> commit(long transactionId, Set<? extends CellId> cells) {
        synchronized (conflictMap) {
            SettableFuture<Long> f = SettableFuture.create();
            if (transactionId < lwm.get()) {
                f.setException(new AbortException());
                return new ForwardingTSOFuture<>(f);
            }

            boolean canCommit = true;
            for (CellId c : cells) {
                int index = Math.abs((int) (c.getCellId() % CONFLICT_MAP_SIZE));
                if (conflictMap[index] >= transactionId) {
                    canCommit = false;
                    break;
                }
            }

            if (canCommit) {
                long commitTimestamp = timestampGenerator.incrementAndGet();
                for (CellId c : cells) {
                    int index = Math.abs((int) (c.getCellId() % CONFLICT_MAP_SIZE));
                    long oldVal = conflictMap[index];
                    conflictMap[index] = commitTimestamp;
                    long curLwm = lwm.get();
                    while (oldVal > curLwm) {
                        if (lwm.compareAndSet(curLwm, oldVal)) {
                            break;
                        }
                        curLwm = lwm.get();
                    }
                }

                f.set(commitTimestamp);
                try {
                    commitTable.addCommittedTransaction(transactionId, commitTimestamp);
                    commitTable.updateLowWatermark(lwm.get());
                    commitTable.flush();
                } catch (IOException ioe) {
                    f.setException(ioe);
                }
            } else {
                f.setException(new AbortException());
            }
            return new ForwardingTSOFuture<>(f);
        }
    }

    @Override
    public TSOFuture<Void> close() {
        SettableFuture<Void> f = SettableFuture.create();
        f.set(null);
        return new ForwardingTSOFuture<>(f);
    }

    @Override
    public long getEpoch() {
        return 0;
    }

}

1	/*
2	* Licensed to the Apache Software Foundation (ASF) under one
3	* or more contributor license agreements. See the NOTICE file
4	* distributed with this work for additional information
5	* regarding copyright ownership. The ASF licenses this file
6	* to you under the Apache License, Version 2.0 (the
7	* "License"); you may not use this file except in compliance
8	* with the License. You may obtain a copy of the License at
9	*
10	* http://www.apache.org/licenses/LICENSE-2.0
11	*
12	* Unless required by applicable law or agreed to in writing, software
13	* distributed under the License is distributed on an "AS IS" BASIS,
14	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15	* See the License for the specific language governing permissions and
16	* limitations under the License.
17	*/
18	package org.apache.omid.tso.client;
19
20	import com.google.common.util.concurrent.SettableFuture;
21	import org.apache.omid.committable.CommitTable;
22
23	import java.io.IOException;
24	import java.util.Set;
25	import java.util.concurrent.atomic.AtomicLong;
26
27	// TODO Would be nice to compile all util classes for testing to a separate package that clients could import for tests
28	public class MockTSOClient implements TSOProtocol {
29
30	private static final int CONFLICT_MAP_SIZE = 1_000_000;
31
32	private final AtomicLong timestampGenerator = new AtomicLong();	4✔
33	private final long[] conflictMap = new long[CONFLICT_MAP_SIZE];	4✔
34	private final AtomicLong lwm = new AtomicLong();	4✔
35
36	private final CommitTable.Writer commitTable;
37
38	public MockTSOClient(CommitTable.Writer commitTable) {	4✔
39	this.commitTable = commitTable;	4✔
40	}	4✔
41
42	@Override
43	public TSOFuture<Long> getNewStartTimestamp() {
44	synchronized (conflictMap) {	8✔
45	SettableFuture<Long> f = SettableFuture.create();	8✔
46	f.set(timestampGenerator.incrementAndGet());	8✔
47	return new ForwardingTSOFuture<>(f);	8✔
48	}	×
49	}
50
51	@Override
52	public TSOFuture<Long> commit(long transactionId, Set<? extends CellId> cells) {
53	synchronized (conflictMap) {	8✔
54	SettableFuture<Long> f = SettableFuture.create();	8✔
55	if (transactionId < lwm.get()) {	8✔
56	f.setException(new AbortException());	×
57	return new ForwardingTSOFuture<>(f);	×
58	}
59
60	boolean canCommit = true;	8✔
61	for (CellId c : cells) {	8✔
62	int index = Math.abs((int) (c.getCellId() % CONFLICT_MAP_SIZE));	8✔
63	if (conflictMap[index] >= transactionId) {	8✔
64	canCommit = false;	2✔
65	break;	2✔
66	}
67	}	6✔
68
69	if (canCommit) {	8✔
70	long commitTimestamp = timestampGenerator.incrementAndGet();	6✔
71	for (CellId c : cells) {	6✔
72	int index = Math.abs((int) (c.getCellId() % CONFLICT_MAP_SIZE));	6✔
73	long oldVal = conflictMap[index];	6✔
74	conflictMap[index] = commitTimestamp;	6✔
75	long curLwm = lwm.get();	6✔
76	while (oldVal > curLwm) {	6✔
77	if (lwm.compareAndSet(curLwm, oldVal)) {	2✔
78	break;	2✔
79	}
80	curLwm = lwm.get();	×
81	}
82	}	6✔
83
84	f.set(commitTimestamp);	6✔
85	try {
86	commitTable.addCommittedTransaction(transactionId, commitTimestamp);	6✔
87	commitTable.updateLowWatermark(lwm.get());	6✔
88	commitTable.flush();	6✔
89	} catch (IOException ioe) {	×
90	f.setException(ioe);	×
91	}	6✔
92	} else {	6✔
93	f.setException(new AbortException());	2✔
94	}
95	return new ForwardingTSOFuture<>(f);	8✔
96	}	×
97	}
98
99	@Override
100	public TSOFuture<Void> close() {
101	SettableFuture<Void> f = SettableFuture.create();	×
102	f.set(null);	×
103	return new ForwardingTSOFuture<>(f);	×
104	}
105
106	@Override
107	public long getEpoch() {
108	return 0;	×
109	}
110
111	}

apache / incubator-omid / 66

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous