Examples of nexj.core.runtime.UnitOfWork

nexj.core.runtime.UnitOfWork
Tracks the changes made to object instances and orders the persistence operations.

    * @see nexj.core.persistence.OIDGenerator#generateOID(Instance, nexj.core.persistence.PersistenceAdapter)
    */
   public OID generateOID(Instance instance, PersistenceAdapter adapter)
   {
      Table table = ((RelationalMapping)instance.getPersistenceMapping()).getPrimaryTable();
      UnitOfWork uow = instance.getUnitOfWork();
      Object key = new Pair(table, KEY);
      Object count = uow.getCachedLocal(key);


      if (count == null)
      {
         Column column = table.getPrimaryKey().getIndexColumn(0).getColumn();
         StringBuffer buf = new StringBuffer(128);


         buf.append("select max(");
         buf.append(column.getQuotedName());
         buf.append(") + 1 from ");
         buf.append(table.getQuotedName());


         SQLAdapter sqlAdapter = (SQLAdapter)adapter;
         SQLConnection connection = null;
         PreparedStatement stmt = null;
         ResultSet rs = null;


         try
         {
            connection = sqlAdapter.getConnection();
            stmt = connection.getConnection().prepareStatement(buf.toString());
            rs = sqlAdapter.executeQuery(stmt);
            rs.next();


            count = rs.getObject(1);


            if (count == null)
            {
               count = Primitive.ONE_INTEGER;
            }


            count = column.getType().convert(count);
         }
         catch (SQLException e)
         {
            throw sqlAdapter.getException(e, null, 0, 0);
         }
         finally
         {
            if (rs != null)
            {
               try
               {
                  rs.close();
               }
               catch (SQLException e)
               {
               }
            }


            if (stmt != null)
            {
               try
               {
                  stmt.close();
               }
               catch (SQLException e)
               {
               }
            }


            if (connection != null)
            {
               connection.decRef();
            }
         }
      }
      else
      {
         count = Primitive.add(count, Primitive.ONE_INTEGER);
      }


      uow.cacheLocal(key, count);


      return new OID(new Object[]{count});
   }

View Full Code Here

      final Metadata metadata = m_context.getMetadata();
      final MessageParser parser = (MessageParser)metadata.getFormat("XML").getParser().getInstance(m_context);
      final MessageFormatter formatter = (MessageFormatter)metadata.getFormat("Object").getFormatter().getInstance(m_context);
      final Transformation transformation = metadata.getTransformation(sTransformation);
      final Transformer transformer = new Transformer(m_context);
      final UnitOfWork uow = m_context.getUnitOfWork();
      final boolean bRawSaved = uow.isRaw();


      try
      {
         uow.setRaw(true);


         final List tobjList = new ArrayList();


         loader.seedResources(((XMLMetadata)metadata).getHelper(), new CharacterStreamHandler()
         {
            public void handleCharacterStream(Reader reader, String sName) throws IOException
            {
               try
               {
                  TransferObject tobj = parser.parse(new ReaderInput(reader), (Message)transformation.getSource());


                  tobj.setValue("name", sName);


                  if (enabled != null && !Intrinsic.isTrue(m_context.getMachine().invoke(enabled, tobj, (Object[])null)))
                  {
                     return;
                  }


                  if (delete != null)
                  {
                     m_context.getMachine().invoke(delete, tobj, (Object[])null);
                  }


                  tobj = transformer.transform(tobj, transformation);
                  tobjList.add(tobj);
               }
               catch (Exception e)
               {
                  s_logger.error("Unable to seed resource \"" + sName + "\"", e);


                  if (e instanceof RuntimeException)
                  {
                     throw (RuntimeException)e;
                  }


                  throw new UncheckedException("err.runtime.seed", new Object[]{sName}, e);
               }
            }
         });


         // Commit the deletes
         uow.commit(false);


         for (Iterator itr = tobjList.iterator(); itr.hasNext();)
         {
            formatter.format((TransferObject)itr.next(), (Message)transformation.getDestination(), new ObjectOutput());
         }


         // Commit the inserts/updates
         uow.commit(false);
      }
      finally
      {
         uow.setRaw(bRawSaved);
      }
   }

View Full Code Here

    */
   public static Instance audit(Instance instance, PropertyMap tobj,
      String sClass, String sEvent, int nArgCount,
      String sAuditClass, byte nMode, InvocationContext context)
   {
      UnitOfWork uowSaved = context.setAuditUnitOfWork();
      boolean bSecureSaved = context.isSecure();


      try
      {
         context.setSecure(false);

View Full Code Here

    * @throws a collection of all the exceptions that occur during formatting.
    */
   public void formatFailSafe(TransferObject tobj, Message message, Output out, boolean bCommit, int nRetry)
      throws CompoundIntegrationException
   {
      UnitOfWork oldUOW = m_context.beginTransaction(); // We use unit of work to recover from database failures
      String sOriginalEvent = tobj.getEventName();


      try
      {
         format(tobj, message, out);

View Full Code Here

         {
            s_logger.debug("Formatting chunk of size " + chunk.size() + (nRetry == 0 ? "" : ", retry #" + nRetry));
         }


         // We use unit of work to recover from database failures
         UnitOfWork oldUOW = m_context.beginTransaction();


         try
         {
            Collection result = new ArrayList(chunk.size());

View Full Code Here

         {
            return Primitive.createLong(counter.next());
         }
      }


      UnitOfWork uowOld = m_context.beginTransaction(false);
      boolean bCommitted = false;


      try
      {
         InstanceList list = Query.createRead(metaclass, ATTRIBUTES,

View Full Code Here

               {
                  GenericSerializablePropertyMap map = new GenericSerializablePropertyMap();


                  map.deserializeValues(message.getStringProperty(JMSSender.STATE), context);


                  UnitOfWork uow = context.getUnitOfWork();


                  for (PropertyIterator itr = map.getIterator(); itr.hasNext();)
                  {
                     itr.next();
                     uow.setValue(itr.getName(), itr.getValue());
                  }
               }
            }


            boolean bProcessed = false;

View Full Code Here

               throw new RequestVersionException("err.rpc.requestVersion",
                  new Object[]{metadata.getVersion(), request.getVersion()});
            }
         }


         UnitOfWork uow = m_context.initUnitOfWork();


         uow.checkLicense();


         if (m_interceptor != null && m_interceptor.isEnabled(m_context))
         {
            m_interceptor.interceptRequest(request);
         }


         if (request.isAsync())
         {
            if (request.isCommit())
            {
               if (s_logger.isDebugEnabled() && !bStealth)
               {
                  s_logger.debug("Asynchronous request - forwarding to " + UnitOfWork.SYSTEM_QUEUE);
               }


               TransferObject properties = new TransferObject(1);


               properties.setValue(JMSSender.USER, m_context.getPrincipal().getName());
               uow.addMessage(UnitOfWork.SYSTEM_QUEUE, request, properties, -1, -1, false);
               m_context.complete(true);
            }


            Response response = new Response();


            if (s_logger.isDumpEnabled() && !bStealth)
            {
               s_logger.dump(response);
            }


            return response;
         }


         m_context.setAudited(false);


         boolean bTransient = !request.isCommit();


         uow.setTransient(bTransient);


         // Add to the unit of work the classes to track
         int nFilterCount = request.getFilterCount();
         boolean bInstanceFilter = false;


         for (int i = 0; i < nFilterCount; ++i)
         {
            TransferObject tobj = request.getFilter(i);


            if (tobj == null || tobj.getClassName() == null)
            {
               throw new RequestException("err.rpc.filterTO");
            }


            m_context.track(metadata.getMetaclass(tobj.getClassName()));


            if (!bInstanceFilter)
            {
               bInstanceFilter = tobj.hasValue("instances");
            }
         }


         int nInvocationCount = request.getInvocationCount();
         Lookup identityMap = new HashTab(nInvocationCount << 1);
         Lookup eventMap = new HashTab(nInvocationCount);
         Event[] eventArray = new Event[nInvocationCount];


         argArray = new Object[nInvocationCount][];
         InstanceFactory instanceFactory = new InstanceFactory(identityMap,
            new ArrayList(nInvocationCount << 3), InstanceFactory.STATE | InstanceFactory.PRE,
            m_context);


         // Instantiate the request objects
         for (int i = 0; i < nInvocationCount; ++i)
         {
            Request.Invocation invocation = request.getInvocation(i);
            TransferObject tobj = invocation.getObject();
            String sEventName = invocation.getEventName();


            if (sEventName == null)
            {
               sEventName = tobj.getEventName();
            }


            if (tobj == null || tobj.getClassName() == null || sEventName == null)
            {
               throw new RequestException("err.rpc.requestTO");
            }


            m_context.setTransient(bTransient);


            Object[] arguments = invocation.getArguments();
            Metaclass metaclass = metadata.getMetaclass(tobj.getClassName());
            Selector selector = metaclass.getSelector(sEventName);
            Member member;
            int nArgCount;


            if (arguments != null)
            {
               nArgCount = arguments.length;
               member = selector.getMember(nArgCount);


               if (member.isStatic() && tobj.getValueCount() != 0)
               {
                  throw new RequestException("err.rpc.requestTO");
               }
            }
            else
            {
               nArgCount = tobj.getValueCount();
               member = selector.findMember(0);


               if (member == null || member.isStatic())
               {
                  member = selector.getMember(nArgCount);


                  if (!member.isStatic())
                  {
                     throw new RequestException("err.rpc.argCount",
                        new Object[]{member.getName(), metaclass.getName()});
                  }
               }
               else
               {
                  nArgCount = 0;
               }
            }


            if (member.isAttribute())
            {
               throw new RequestException("err.rpc.attributeInvocation",
                  new Object[]{member.getName(), metaclass.getName()});
            }


            if (m_context.isProtected() && member.getVisibility() != Metaclass.PUBLIC)
            {
               throw new SecurityViolationException("err.rpc.eventVisibility",
                  new Object[]{member.getName(), metaclass.getName()});
            }


            Event event = (Event)member;
            Object[] args = new Object[nArgCount + 1];


            if (arguments != null)
            {
               for (int k = 0; k < nArgCount; ++k)
               {
                  args[k + 1] = instanceFactory.instantiate(arguments[k]); 
               }
            }


            if (event.isStatic())
            {
               args[0] = metaclass;


               if (arguments == null)
               {
                  int nEventArgCount = event.getArgumentCount();


                  if (event.isVarArg())
                  {
                     --nEventArgCount;
                  }


                  for (int k = 0; k < nEventArgCount; ++k)
                  {
                     args[k + 1] = instanceFactory.instantiate(tobj.getValue(event.getArgument(k).getName())); 
                  }


                  if (event.isVarArg())
                  {
                     int nArg = nEventArgCount;


                     for (PropertyIterator itr = tobj.getIterator(); itr.hasNext();)
                     {
                        itr.next();


                        Argument arg = event.findArgument(itr.getName());


                        if (arg == null || arg == event.getArgument(nEventArgCount))
                        {
                           args[++nArg] = new Pair(Symbol.define(itr.getName()), instanceFactory.instantiate(itr.getValue()));
                        }
                     }
                  }
               }


               // Allow auditing of static events
               identityMap.put(tobj, null);
            }
            else
            {
               args[0] = instanceFactory.instantiate(tobj);
            }


            eventArray[i] = event;
            argArray[i] = args;
            eventMap.put(tobj, event);
         }


         Lookup diffMap = null;


         // Instantiate the transfer objects from the instance filters
         if (bInstanceFilter)
         {
            diffMap = new HashTab();


            for (int i = 0; i < nFilterCount; ++i)
            {
               m_context.setTransient(bTransient);


               TransferObject tobj = request.getFilter(i);
               Object instances = tobj.findValue("instances");


               if (instances != null)
               {
                  List instanceList = (List)instances;
                  int nCount = instanceList.size();


                  for (int k = 0; k < nCount; ++k)
                  {
                     tobj = (TransferObject)instanceList.get(k);


                     Instance inst = instanceFactory.instantiate(tobj);


                     instanceList.set(k, inst);


                     if (inst != null)
                     {
                        diffMap.put(inst, tobj);
                     }
                  }
               }
            }
         }


         instanceFactory.complete();
         instanceFactory = null;
         GenericServer.auditRequest(identityMap, eventMap, m_context);
         identityMap = null;


         Object[] resultArray = new Object[nInvocationCount << 1];


         // Unset the pending event flag on the request argument instances
         for (int i = 0; i < nInvocationCount; ++i)
         {
            Object[] args = argArray[i];
            Object obj = args[0];


            if (obj instanceof Instance)
            {
               Instance instance = (Instance)obj;


               if (args.length == 1 && eventArray[i].getName().equals(instance.getPendingEventName()))
               {
                  resultArray[i << 1] = instance;
               }


               instance.suspendEvent();
            }
         }


         m_context.setTransient(false);
         uow.invokePendingEvents(false, false);


         // Invoke the events and accumulate the results
         for (int i = 0; i < nInvocationCount; ++i)
         {
            TransferObject tobj = request.getObject(i);
            Event event = eventArray[i];
            Pair attributes = EMPTY_PAIR;
            Object[] args = argArray[i];
            Object obj = args[0];
            int nAttrIndex = -1;


            m_context.setTransient(event.isTransient(bTransient));


            if (event.getArgumentCount() != 0)
            {
               Argument arg = event.findArgument("attributes");


               if (arg != null)
               {
                  nAttrIndex = arg.getOrdinal() + 1;


                  Object value = args[nAttrIndex];


                  attributes = (value instanceof Pair) ? (Pair)value : null;
               }
            }


            if (nAttrIndex < 0)
            {
               Object value = tobj.findValue("attributes", EMPTY_PAIR);


               if (value != EMPTY_PAIR)
               {
                  nAttrIndex = 0;
                  attributes =  (Pair)value;
               }
            }


            if (event.isStatic() && m_context.isProtected() && m_context.isSecure())
            {
               Metaclass metaclass = event.getMetaclass();
               Argument result = event.getResult();


               if (result != null && !result.getType().isPrimitive())
               {
                  metaclass = (Metaclass)result.getType();
               }


               if (nAttrIndex > 0)
               {
                  Pair security = metaclass.checkReadAccess(attributes, m_context.getPrivilegeSet());
   
                  if (security != null)
                  {
                     args[nAttrIndex] = Pair.nconc(security, attributes);
                  }
               }


               metaclass.checkExpressionAccess(findArg(event, "where", args, tobj),  m_context.getPrivilegeSet());
               metaclass.checkOrderByAccess(findArg(event, "orderBy", args, tobj), m_context.getPrivilegeSet());
            }


            boolean bInvoked = false;
            boolean bDeleted = false;


            m_context.setUnitOfWork(uow);
            m_context.setTransient(event.isTransient(bTransient));


            if (obj instanceof Instance)
            {
               Instance instance = (Instance)obj;
               UnitOfWork instanceUOW = instance.getUnitOfWork();


               // Use the instance UoW
               if (!event.isStatic() && instanceUOW != null && instanceUOW != uow)
               {
                  m_context.setUnitOfWork(instanceUOW);
               }


               bInvoked = instance.invokeSuspendedEvent();
               bDeleted = (instance.getState() == Instance.DELETED);


               if (nAttrIndex <= 0)
               {
                  Attribute attribute = instance.getMetaclass().findAttribute("attributes");


                  if (attribute != null && !attribute.isStatic())
                  {
                     attributes = (Pair)instance.getValue(attribute.getOrdinal());
                  }
               }
            }


            if (resultArray[i << 1] == null)
            {
               if (!bDeleted)
               {
                  resultArray[i << 1] = event.invoke(args, m_context.getMachine());
               }
            }
            else
            {
               if (!bInvoked && !bDeleted)
               {
                  event.invoke(args, m_context.getMachine());
               }


               eventArray[i] = null;
            }


            resultArray[(i << 1) + 1] = attributes;
         }


         // Pre-commit all units of work in the context
         for (int i = m_context.getUnitOfWorkCount() - 1; i >= 0; i--)
         {
            UnitOfWork work = m_context.getUnitOfWork(i);


            m_context.setUnitOfWork(work);


            if (work.isTransient())
            {
               work.invokePendingEvents(true, false);
               work.computeHiddenness();
               work.accumulateChanges();
            }
            else
            {
               work.commit(false);
            }
         }


         m_context.setUnitOfWork(uow);

View Full Code Here

      {
         GenericSerializablePropertyMap map = new GenericSerializablePropertyMap();


         map.deserializeValues(message.getValue(ObjectSender.STATE), context);


         UnitOfWork uow = context.getUnitOfWork();


         for (PropertyIterator itr = map.getIterator(); itr.hasNext();)
         {
            itr.next();
            uow.setValue(itr.getName(), itr.getValue());
         }
      }


      boolean bProcessed = false;

View Full Code Here

               new StreamInput(getInputStream(), sEncoding) :
                  (Input)new ReaderInput(getReader()));


         try
         {
            UnitOfWork uow = m_context.initUnitOfWork();
   
            uow.checkLicense();
            m_context.beginTransaction();
            adapter.receive(tobj, channel, m_context);
            m_context.complete(true);         
         }
         catch (Throwable e)

View Full Code Here

0 1

TOP

Related Classes of nexj.core.runtime.UnitOfWork

nexj.core.integration.format.object.ObjectMessageFormatterStrategy

nexj.core.integration.format.object.ObjectMessageFormatterStrategy$FailSafeFormatter

nexj.core.integration.Sender

nexj.core.meta.Component

nexj.core.meta.integration.Channel

nexj.core.meta.integration.channel.jms.MessageQueue

nexj.core.persistence.PersistenceAdapter

nexj.core.persistence.sql.MaxPlus1Generator

nexj.core.persistence.Work

nexj.core.rpc.GenericServer

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.