summaryrefslogtreecommitdiffstats
path: root/infra/translate-api/src/main/java/io/fd/honeycomb/translate/write/registry/WriterRegistry.java
blob: 2467972dadc4cdd70ca285b45fee7b7c1a8933c7 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
/*
 * Copyright (c) 2016 Cisco and/or its affiliates.
 *
 * Licensed 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 io.fd.honeycomb.translate.write.registry;

import static com.google.common.base.Preconditions.checkNotNull;

import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Multimap;
import com.google.common.collect.Sets;
import io.fd.honeycomb.translate.TranslationException;
import io.fd.honeycomb.translate.write.DataObjectUpdate;
import io.fd.honeycomb.translate.write.WriteContext;
import io.fd.honeycomb.translate.write.Writer;
import java.util.Set;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;

/**
 * Special {@link Writer} capable of performing bulk updates.
 */
@Beta
public interface WriterRegistry {

    /**
     * Performs bulk update.
     *
     * @throws BulkUpdateException in case bulk update fails
     * @throws TranslationException in case some other error occurs while processing update request
     */
    void update(@Nonnull DataObjectUpdates updates,
                @Nonnull WriteContext ctx) throws TranslationException;

    /**
     * Simple DTO containing updates for {@link WriterRegistry}. Currently only deletes and updates (create + update)
     * are distinguished.
     */
    @Beta
    final class DataObjectUpdates {

        private final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates;
        private final Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> deletes;

        /**
         * Create new instance.
         *
         * @param updates All updates indexed by their unkeyed {@link InstanceIdentifier}
         * @param deletes All deletes indexed by their unkeyed {@link InstanceIdentifier}
         */
        public DataObjectUpdates(@Nonnull final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates,
                                 @Nonnull final Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> deletes) {
            this.deletes = deletes;
            this.updates = updates;
        }

        public Multimap<InstanceIdentifier<?>, DataObjectUpdate> getUpdates() {
            return updates;
        }

        public Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> getDeletes() {
            return deletes;
        }

        public boolean isEmpty() {
            return updates.isEmpty() && deletes.isEmpty();
        }

        @Override
        public String toString() {
            return "DataObjectUpdates{" + "updates=" + updates + ", deletes=" + deletes + '}';
        }

        /**
         * Get a {@link Set} containing all update types from both updates as well as deletes.
         */
        public Set<InstanceIdentifier<?>> getTypeIntersection() {
            return Sets.union(deletes.keySet(), updates.keySet());
        }

        /**
         * Check whether there is only a single type of data object to be updated.
         *
         * @return true if there is only a single type of updates (update + delete)
         */
        public boolean containsOnlySingleType() {
            return getTypeIntersection().size() == 1;
        }

        @Override
        public boolean equals(final Object other) {
            if (this == other) {
                return true;
            }
            if (other == null || getClass() != other.getClass()) {
                return false;
            }

            final DataObjectUpdates that = (DataObjectUpdates) other;

            if (!updates.equals(that.updates)) {
                return false;
            }
            return deletes.equals(that.deletes);

        }

        @Override
        public int hashCode() {
            int result = updates.hashCode();
            result = 31 * result + deletes.hashCode();
            return result;
        }

    }

    /**
     * Thrown when bulk update failed.
     */
    @Beta
    class BulkUpdateException extends TranslationException {

        private final Reverter reverter;
        private final Set<InstanceIdentifier<?>> failedIds;

        /**
         * Constructs an BulkUpdateException.
         * @param failedIds instance identifiers of the data objects that were not processed during bulk update.
         * @param cause the cause of bulk update failure
         */
        public BulkUpdateException(@Nonnull final Set<InstanceIdentifier<?>> failedIds,
                                   @Nonnull final Reverter reverter,
                                   @Nonnull final Throwable cause) {
            super("Bulk update failed at: " + failedIds, cause);
            this.failedIds = failedIds;
            this.reverter = checkNotNull(reverter, "reverter should not be null");
        }

        /**
         * Reverts changes that were successfully applied during bulk update before failure occurred.
         *
         * @throws Reverter.RevertFailedException if revert fails
         */
        public void revertChanges() throws Reverter.RevertFailedException {
            reverter.revert();
        }

        public Set<InstanceIdentifier<?>> getFailedIds() {
            return failedIds;
        }
    }

    /**
     * Abstraction over revert mechanism in case of a bulk update failure.
     */
    @Beta
    interface Reverter {

        /**
         * Reverts changes that were successfully applied during bulk update before failure occurred. Changes are
         * reverted in reverse order they were applied.
         *
         * @throws RevertFailedException if not all of applied changes were successfully reverted
         */
        void revert() throws RevertFailedException;

        /**
         * Thrown when some of the changes applied during bulk update were not reverted.
         */
        @Beta
        class RevertFailedException extends TranslationException {

            // TODO change to list of VppDataModifications to make debugging easier
            private final Set<InstanceIdentifier<?>> notRevertedChanges;

            /**
             * Constructs a RevertFailedException with the list of changes that were not reverted.
             *
             * @param notRevertedChanges list of changes that were not reverted
             * @param cause              the cause of revert failure
             */
            public RevertFailedException(@Nonnull final Set<InstanceIdentifier<?>> notRevertedChanges,
                                         final Throwable cause) {
                super(cause);
                checkNotNull(notRevertedChanges, "notRevertedChanges should not be null");
                this.notRevertedChanges = ImmutableSet.copyOf(notRevertedChanges);
            }

            /**
             * Returns the list of changes that were not reverted.
             *
             * @return list of changes that were not reverted
             */
            @Nonnull
            public Set<InstanceIdentifier<?>> getNotRevertedChanges() {
                return notRevertedChanges;
            }
        }
    }
}