X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsamples%2Ftoaster-provider%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsample%2Ftoaster%2Fprovider%2FOpendaylightToaster.java;h=ec352e8f510dad03911be2ad2eeb0ec6a5c44542;hp=2dab924e7709dc74fcb3047272d068f9e459c2d5;hb=a9533db1d57a2729772ee192a2f96d358c71bede;hpb=7f84a4ff3b4480ca4b8d056bd18ee98ed155aa65 diff --git a/opendaylight/md-sal/samples/toaster-provider/src/main/java/org/opendaylight/controller/sample/toaster/provider/OpendaylightToaster.java b/opendaylight/md-sal/samples/toaster-provider/src/main/java/org/opendaylight/controller/sample/toaster/provider/OpendaylightToaster.java index 2dab924e77..ec352e8f51 100644 --- a/opendaylight/md-sal/samples/toaster-provider/src/main/java/org/opendaylight/controller/sample/toaster/provider/OpendaylightToaster.java +++ b/opendaylight/md-sal/samples/toaster-provider/src/main/java/org/opendaylight/controller/sample/toaster/provider/OpendaylightToaster.java @@ -7,6 +7,7 @@ */ package org.opendaylight.controller.sample.toaster.provider; +import java.util.Arrays; import java.util.Collections; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; @@ -16,105 +17,209 @@ import java.util.concurrent.Future; import java.util.concurrent.atomic.AtomicLong; import org.opendaylight.controller.config.yang.config.toaster_provider.impl.ToasterProviderRuntimeMXBean; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.DataChangeListener; +import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; +import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.controller.sal.binding.api.NotificationProviderService; -import org.opendaylight.controller.sal.binding.api.data.DataBrokerService; -import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction; +import org.opendaylight.controller.sal.common.util.RpcErrors; import org.opendaylight.controller.sal.common.util.Rpcs; import org.opendaylight.yang.gen.v1.http.netconfcentral.org.ns.toaster.rev091120.DisplayString; import org.opendaylight.yang.gen.v1.http.netconfcentral.org.ns.toaster.rev091120.MakeToastInput; -import org.opendaylight.yang.gen.v1.http.netconfcentral.org.ns.toaster.rev091120.ToastDone.ToastStatus; -import org.opendaylight.yang.gen.v1.http.netconfcentral.org.ns.toaster.rev091120.ToastDoneBuilder; +import org.opendaylight.yang.gen.v1.http.netconfcentral.org.ns.toaster.rev091120.RestockToasterInput; import org.opendaylight.yang.gen.v1.http.netconfcentral.org.ns.toaster.rev091120.Toaster; import org.opendaylight.yang.gen.v1.http.netconfcentral.org.ns.toaster.rev091120.Toaster.ToasterStatus; import org.opendaylight.yang.gen.v1.http.netconfcentral.org.ns.toaster.rev091120.ToasterBuilder; -import org.opendaylight.yang.gen.v1.http.netconfcentral.org.ns.toaster.rev091120.ToasterData; +import org.opendaylight.yang.gen.v1.http.netconfcentral.org.ns.toaster.rev091120.ToasterOutOfBreadBuilder; +import org.opendaylight.yang.gen.v1.http.netconfcentral.org.ns.toaster.rev091120.ToasterRestocked; +import org.opendaylight.yang.gen.v1.http.netconfcentral.org.ns.toaster.rev091120.ToasterRestockedBuilder; import org.opendaylight.yang.gen.v1.http.netconfcentral.org.ns.toaster.rev091120.ToasterService; +import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.common.RpcError; +import org.opendaylight.yangtools.yang.common.RpcError.ErrorSeverity; +import org.opendaylight.yangtools.yang.common.RpcError.ErrorType; import org.opendaylight.yangtools.yang.common.RpcResult; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.google.common.util.concurrent.Futures; -public class OpendaylightToaster implements ToasterData, ToasterService, ToasterProviderRuntimeMXBean, AutoCloseable { +public class OpendaylightToaster implements ToasterService, ToasterProviderRuntimeMXBean, + DataChangeListener, AutoCloseable { - private static final Logger log = LoggerFactory.getLogger(OpendaylightToaster.class); - private static final InstanceIdentifier toasterIID = InstanceIdentifier.builder(Toaster.class).build(); + private static final Logger LOG = LoggerFactory.getLogger(OpendaylightToaster.class); - private static final DisplayString toasterManufacturer = new DisplayString("Opendaylight"); - private static final DisplayString toasterModelNumber = new DisplayString("Model 1 - Binding Aware"); + public static final InstanceIdentifier TOASTER_IID = InstanceIdentifier.builder(Toaster.class).build(); + + private static final DisplayString TOASTER_MANUFACTURER = new DisplayString("Opendaylight"); + private static final DisplayString TOASTER_MODEL_NUMBER = new DisplayString("Model 1 - Binding Aware"); private NotificationProviderService notificationProvider; - private DataBrokerService dataProvider; + private DataBroker dataProvider; + private final ExecutorService executor; - private Future> currentTask; + // As you will see we are using multiple threads here. Therefore we need to be careful about concurrency. + // In this case we use the taskLock to provide synchronization for the current task. + private volatile Future> currentTask; + private final Object taskLock = new Object(); + + private final AtomicLong amountOfBreadInStock = new AtomicLong( 100 ); + + private final AtomicLong toastsMade = new AtomicLong(0); + + // Thread safe holder for our darkness multiplier. + private final AtomicLong darknessFactor = new AtomicLong( 1000 ); public OpendaylightToaster() { executor = Executors.newFixedThreadPool(1); } + public void setNotificationProvider(final NotificationProviderService salService) { + this.notificationProvider = salService; + } + + public void setDataProvider(final DataBroker salDataProvider) { + this.dataProvider = salDataProvider; + updateStatus(); + } + + /** + * Implemented from the AutoCloseable interface. + */ @Override - public synchronized Toaster getToaster() { - ToasterBuilder tb = new ToasterBuilder(); - tb // - .setToasterManufacturer(toasterManufacturer) // - .setToasterModelNumber(toasterModelNumber) // - .setToasterStatus(currentTask == null ? ToasterStatus.Up : ToasterStatus.Down); + public void close() throws ExecutionException, InterruptedException { + // When we close this service we need to shutdown our executor! + executor.shutdown(); + if (dataProvider != null) { + WriteTransaction t = dataProvider.newWriteOnlyTransaction(); + t.delete(LogicalDatastoreType.OPERATIONAL,TOASTER_IID); + t.commit().get(); // FIXME: This call should not be blocking. + } + } + + private Toaster buildToaster() { + // We don't need to synchronize on currentTask here b/c it's declared volatile and + // we're just doing a read. + boolean isUp = currentTask == null; + + // note - we are simulating a device whose manufacture and model are + // fixed (embedded) into the hardware. + // This is why the manufacture and model number are hardcoded. + ToasterBuilder tb = new ToasterBuilder(); + tb.setToasterManufacturer(TOASTER_MANUFACTURER).setToasterModelNumber(TOASTER_MODEL_NUMBER) + .setToasterStatus(isUp ? ToasterStatus.Up : ToasterStatus.Down); return tb.build(); } + /** + * Implemented from the DataChangeListener interface. + */ @Override - public synchronized Future> cancelToast() { - if (currentTask != null) { - cancelToastImpl(); + public void onDataChanged( final AsyncDataChangeEvent, DataObject> change ) { + DataObject dataObject = change.getUpdatedSubtree(); + if( dataObject instanceof Toaster ) + { + Toaster toaster = (Toaster) dataObject; + Long darkness = toaster.getDarknessFactor(); + if( darkness != null ) + { + darknessFactor.set( darkness ); + } } - return null; } + /** + * RestConf RPC call implemented from the ToasterService interface. + */ @Override - public synchronized Future> makeToast(MakeToastInput input) { - log.debug("makeToast - Received input for toast"); - logToastInput(input); - if (currentTask != null) { - return inProgressError(); + public Future> cancelToast() { + synchronized (taskLock) { + if (currentTask != null) { + currentTask.cancel(true); + currentTask = null; + } } - currentTask = executor.submit(new MakeToastTask(input)); - updateStatus(); - return currentTask; + // Always return success from the cancel toast call. + return Futures.immediateFuture(Rpcs. getRpcResult(true, Collections. emptySet())); } - private Future> inProgressError() { - RpcResult result = Rpcs. getRpcResult(false, null, Collections. emptySet()); - return Futures.immediateFuture(result); - } + /** + * RestConf RPC call implemented from the ToasterService interface. + */ + @Override + public Future> makeToast(final MakeToastInput input) { + LOG.info("makeToast: " + input); - private void cancelToastImpl() { - currentTask.cancel(true); - ToastDoneBuilder toastDone = new ToastDoneBuilder(); - toastDone.setToastStatus(ToastStatus.Cancelled); - notificationProvider.publish(toastDone.build()); - } + synchronized (taskLock) { + if (currentTask != null) { + // return an error since we are already toasting some toast. + LOG.info( "Toaster is already making toast" ); - public void setNotificationProvider(NotificationProviderService salService) { - this.notificationProvider = salService; - } + RpcResult result = Rpcs. getRpcResult(false, null, Arrays.asList( + RpcErrors.getRpcError( "", "in-use", null, ErrorSeverity.WARNING, + "Toaster is busy", ErrorType.APPLICATION, null ) ) ); + return Futures.immediateFuture(result); + } + else if( outOfBread() ) { + RpcResult result = Rpcs. getRpcResult(false, null, Arrays.asList( + RpcErrors.getRpcError( "out-of-stock", "resource-denied", null, null, + "Toaster is out of bread", + ErrorType.APPLICATION, null ) ) ); + return Futures.immediateFuture(result); + } + else { + // Notice that we are moving the actual call to another thread, + // allowing this thread to return immediately. + // The MD-SAL design encourages asynchronus programming. If the + // caller needs to block until the call is + // complete then they can leverage the blocking methods on the + // Future interface. + currentTask = executor.submit(new MakeToastTask(input)); + } + } - public void setDataProvider(DataBrokerService salDataProvider) { - this.dataProvider = salDataProvider; updateStatus(); + return currentTask; } - private void logToastInput(MakeToastInput input) { - String toastType = input.getToasterToastType().getName(); - String toastDoneness = input.getToasterDoneness().toString(); - log.trace("Toast: {} doneness: {}", toastType, toastDoneness); + /** + * RestConf RPC call implemented from the ToasterService interface. + * Restocks the bread for the toaster, resets the toastsMade counter to 0, and sends a + * ToasterRestocked notification. + */ + @Override + public Future> restockToaster(final RestockToasterInput input) { + LOG.info( "restockToaster: " + input ); + + synchronized( taskLock ) { + amountOfBreadInStock.set( input.getAmountOfBreadToStock() ); + + if( amountOfBreadInStock.get() > 0 ) { + ToasterRestocked reStockedNotification = + new ToasterRestockedBuilder().setAmountOfBread( input.getAmountOfBreadToStock() ).build(); + notificationProvider.publish( reStockedNotification ); + } + } + + return Futures.immediateFuture(Rpcs. getRpcResult(true, Collections. emptySet())); } - private final AtomicLong toastsMade = new AtomicLong(0); + /** + * JMX RPC call implemented from the ToasterProviderRuntimeMXBean interface. + */ + @Override + public void clearToastsMade() { + LOG.info( "clearToastsMade" ); + toastsMade.set( 0 ); + } + /** + * Accesssor method implemented from the ToasterProviderRuntimeMXBean interface. + */ @Override public Long getToastsMade() { return toastsMade.get(); @@ -122,51 +227,62 @@ public class OpendaylightToaster implements ToasterData, ToasterService, Toaster private void updateStatus() { if (dataProvider != null) { - final DataModificationTransaction t = dataProvider.beginTransaction(); - t.removeOperationalData(toasterIID); - t.putOperationalData(toasterIID, getToaster()); + WriteTransaction tx = dataProvider.newWriteOnlyTransaction(); + tx.put(LogicalDatastoreType.OPERATIONAL,TOASTER_IID, buildToaster()); try { - t.commit().get(); + tx.commit().get(); } catch (InterruptedException | ExecutionException e) { - log.warn("Failed to update toaster status, operational otherwise", e); + LOG.warn("Failed to update toaster status, operational otherwise", e); } } else { - log.trace("No data provider configured, not updating status"); + LOG.trace("No data provider configured, not updating status"); } } - @Override - public void close() throws ExecutionException, InterruptedException { - if (dataProvider != null) { - final DataModificationTransaction t = dataProvider.beginTransaction(); - t.removeOperationalData(toasterIID); - t.commit().get(); - } + private boolean outOfBread() + { + return amountOfBreadInStock.get() == 0; } private class MakeToastTask implements Callable> { final MakeToastInput toastRequest; - public MakeToastTask(MakeToastInput toast) { + public MakeToastTask(final MakeToastInput toast) { toastRequest = toast; } @Override - public RpcResult call() throws InterruptedException { - Thread.sleep(1000 * toastRequest.getToasterDoneness()); + public RpcResult call() { + try + { + // make toast just sleeps for n secondn per doneness level. + long darknessFactor = OpendaylightToaster.this.darknessFactor.get(); + Thread.sleep(darknessFactor * toastRequest.getToasterDoneness()); - ToastDoneBuilder notifyBuilder = new ToastDoneBuilder(); - notifyBuilder.setToastStatus(ToastStatus.Done); - notificationProvider.publish(notifyBuilder.build()); - log.debug("Toast Done"); - logToastInput(toastRequest); + } + catch( InterruptedException e ) { + LOG.info( "Interrupted while making the toast" ); + } - currentTask = null; toastsMade.incrementAndGet(); + + amountOfBreadInStock.getAndDecrement(); + if( outOfBread() ) { + LOG.info( "Toaster is out of bread!" ); + + notificationProvider.publish( new ToasterOutOfBreadBuilder().build() ); + } + + synchronized (taskLock) { + currentTask = null; + } + updateStatus(); + LOG.debug("Toast done"); + return Rpcs. getRpcResult(true, null, Collections. emptySet()); } }