Package nexj.core.runtime

Examples of nexj.core.runtime.UnitOfWork$MessageFactory


    * @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

TOP

Related Classes of nexj.core.runtime.UnitOfWork$MessageFactory

Copyright © 2018 www.massapicom. All rights reserved.
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.