Inheritance: OtpErlangObject
Example #1
0
        /**
         * Send a pre-encoded message to a process on a remote node.
         */
        protected void SendBuf(OtpErlangPid from, OtpErlangPid dest, OtpOutputStream payload)
        {
            if (!Connected)
            {
                throw new IOException("Not connected");
            }

            OtpOutputStream header = new OtpOutputStream(headerLen);

            // preamble: 4 byte length + "passthrough" tag + version
            header.Write4BE(0); // reserve space for length
            header.Write1(passThrough);
            header.Write1(version);

            // header info
            header.WriteTupleHead(3);
            header.WriteLong(sendTag);
            if (sendCookie)
            {
                header.WriteAtom(Local.Cookie);
            }
            else
            {
                header.WriteAtom("");
            }
            header.WriteAny(dest);

            // version for payload
            header.Write1(version);

            // fix up length in preamble
            header.Poke4BE(0, header.Length + payload.Length - 4);

            DoSend(header, payload);
        }
Example #2
0
 public bool exists(OtpErlangPid local, OtpErlangPid remote)
 {
     lock (this)
     {
         return(find(local, remote) != -1);
     }
 }
Example #3
0
        public int compareTo(Object o)
        {
            if (!(o is OtpErlangPid))
            {
                return(-1);
            }

            OtpErlangPid pid = (OtpErlangPid)o;

            if (creation == pid.creation)
            {
                if (serial == pid.serial)
                {
                    if (id == pid.id)
                    {
                        return(node.CompareTo(pid.node));
                    }
                    else
                    {
                        return(id - pid.id);
                    }
                }
                else
                {
                    return(serial - pid.serial);
                }
            }
            else
            {
                return(creation - pid.creation);
            }
        }
Example #4
0
        // this function used internally when "process" dies
        // since Erlang discerns between exit and exit/2.
        private void exit(int arity, OtpErlangPid to, OtpErlangObject reason)
        {
            try
            {
                String node = to.Node;
                if (node.Equals(home.Node))
                {
                    home.deliver(new OtpMsg(OtpMsg.exitTag, self, to, reason));
                }
                else
                {
                    OtpCookedConnection conn = home.getConnection(node);
                    if (conn == null)
                    {
                        return;
                    }
                    switch (arity)
                    {
                    case 1:
                        conn.exit(self, to, reason);
                        break;

                    case 2:
                        conn.exit2(self, to, reason);
                        break;
                    }
                }
            }
            catch (Exception)
            {
            }
        }
Example #5
0
        /**
         * Send an exit signal to a remote process.
         * Used internally when "processes" terminate
         */
        private void SendExit(int tag, OtpErlangPid from, OtpErlangPid dest, IOtpErlangObject reason)
        {
            if (!Connected)
            {
                throw new IOException("Not connected");
            }

            OtpOutputStream header = new OtpOutputStream(headerLen);

            // preamble: 4 byte length + "passthrough" tag
            header.Write4BE(0); // reserve space for length
            header.Write1(passThrough);
            header.Write1(version);

            // header
            header.WriteTupleHead(4);
            header.WriteLong(tag);
            header.WriteAny(from);
            header.WriteAny(dest);
            header.WriteAny(reason);

            // fix up length in preamble
            header.Poke4BE(0, header.Length - 4);

            DoSend(header);
        }
Example #6
0
        /**
         * Link to a remote mailbox or Erlang process. Links are idempotent, calling
         * this method multiple times will not result in more than one link being
         * created.
         *
         * If the remote process subsequently exits or the mailbox is closed, a
         * subsequent attempt to retrieve a message through this mailbox will cause
         * an {@link OtpErlangExit OtpErlangExit} exception to be raised. Similarly,
         * if the sending mailbox is closed, the linked mailbox or process will
         * receive an exit signal.
         *
         * If the remote process cannot be reached in order to set the link, the
         * exception is raised immediately.
         */
        public void Link(OtpErlangPid to)
        {
            try
            {
                string node = to.Node;
                if (node.Equals(home.Node))
                {
                    if (!home.Deliver(new OtpMsg(OtpMsg.linkTag, Self, to)))
                    {
                        throw new OtpExit("noproc", to);
                    }
                }
                else
                {
                    OtpCookedConnection conn = home.GetConnection(node);
                    if (conn == null)
                    {
                        throw new OtpExit("noproc", to);
                    }
                    conn.Link(Self, to);
                }
            }
            catch (Exception) { }

            links.AddLink(Self, to);
        }
Example #7
0
 /**
  * package constructor: called by OtpNode:createMbox(name) to create a named mbox
  */
 internal OtpMbox(OtpNode home, OtpErlangPid self, string name)
 {
     Name      = name;
     Self      = self;
     this.home = home;
     links     = new Links(10);
 }
Example #8
0
        // this function used internally when "process" dies
        // since Erlang discerns between exit and exit/2.
        private void Exit(int arity, OtpErlangPid to, IOtpErlangObject reason)
        {
            try
            {
                string node = to.Node;
                if (node.Equals(home.Node))
                {
                    home.Deliver(new OtpMsg(OtpMsg.exitTag, Self, to, reason));
                    return;
                }

                OtpCookedConnection conn = home.GetConnection(node);
                if (conn == null)
                {
                    return;
                }

                switch (arity)
                {
                case 1:
                    conn.Exit(Self, to, reason);
                    break;

                case 2:
                    conn.Exit2(Self, to, reason);
                    break;
                }
            }
            catch (Exception) { }
        }
Example #9
0
        /*
         * this method simulates net_kernel only for the purpose of replying to
         * pings.
         */
        private bool netKernel(OtpMsg m)
        {
            OtpMbox mbox = null;

            try
            {
                OtpErlangTuple t   = (OtpErlangTuple)m.getMsg();
                OtpErlangTuple req = (OtpErlangTuple)t.elementAt(1); // actual
                // request

                OtpErlangPid pid = (OtpErlangPid)req.elementAt(0); // originating
                // pid

                OtpErlangObject[] pong = new OtpErlangObject[2];
                pong[0] = req.elementAt(1); // his #Ref
                pong[1] = new OtpErlangAtom("yes");

                mbox = createMbox(true);
                mbox.send(pid, new OtpErlangTuple(pong));
                return(true);
            }
            catch (Exception)
            {
            }
            finally
            {
                closeMbox(mbox);
            }
            return(false);
        }
Example #10
0
        /**
         * <p>
         * Link to a remote mailbox or Erlang process. Links are idempotent, calling
         * this method multiple times will not result in more than one link being
         * created.
         * </p>
         *
         * <p>
         * If the remote process subsequently exits or the mailbox is closed, a
         * subsequent attempt to retrieve a message through this mailbox will cause
         * an {@link OtpErlangExit OtpErlangExit} exception to be raised. Similarly,
         * if the sending mailbox is closed, the linked mailbox or process will
         * receive an exit signal.
         * </p>
         *
         * <p>
         * If the remote process cannot be reached in order to set the link, the
         * exception is raised immediately.
         * </p>
         *
         * @param to
         *                the {@link OtpErlangPid pid} representing the object to
         *                link to.
         *
         * @exception OtpErlangExit
         *                    if the {@link OtpErlangPid pid} referred to does not
         *                    exist or could not be reached.
         *
         */
        public void link(OtpErlangPid to)
        {
            try
            {
                String node = to.Node;
                if (node.Equals(home.Node))
                {
                    if (!home.deliver(new OtpMsg(OtpMsg.linkTag, self, to)))
                    {
                        throw new OtpErlangExit("noproc", to);
                    }
                }
                else
                {
                    OtpCookedConnection conn = home.getConnection(node);
                    if (conn != null)
                    {
                        conn.link(self, to);
                    }
                    else
                    {
                        throw new OtpErlangExit("noproc", to);
                    }
                }
            }
            catch (OtpErlangExit e)
            {
                throw e;
            }
            catch (Exception)
            {
            }

            links.addLink(self, to);
        }
 /*
  * snoop for outgoing unlinks and update own table
  */
 public void Unlink(OtpErlangPid from, OtpErlangPid to)
 {
     lock (lockObj)
         links.RemoveLink(from, to);
     try { SendUnlink(from, to); }
     catch (IOException) { }
 }
Example #12
0
 // package constructor: called by OtpNode:createMbox(name)
 // to create a named mbox
 internal OtpMbox(OtpNode home, OtpErlangPid self, String name)
 {
     this.self = self;
     this.home = home;
     this.name = name;
     queue     = new GenericQueue();
     links     = new Links(10);
 }
Example #13
0
 /**
  * Write an Erlang PID to the stream.
  */
 public void WritePid(OtpErlangPid pid)
 {
     Write1(OtpExternal.newPidTag);
     WriteAtom(pid.Node);
     Write4BE(pid.Id);
     Write4BE(pid.Serial);
     Write4BE(pid.Creation);
 }
Example #14
0
 // exit (etc) has from, to, reason
 internal OtpMsg(int tag, OtpErlangPid from, OtpErlangPid to, OtpErlangObject reason)
 {
     this.tag  = tag;
     this.from = from;
     this.to   = to;
     paybuf    = null;
     payload   = reason;
 }
Example #15
0
 // special case when reason is an atom (i.e. most of the time)
 internal OtpMsg(int tag, OtpErlangPid from, OtpErlangPid to, String reason)
 {
     this.tag  = tag;
     this.from = from;
     this.to   = to;
     paybuf    = null;
     payload   = new OtpErlangAtom(reason);
 }
Example #16
0
 // send_reg has sender pid and receiver name
 internal OtpMsg(OtpErlangPid from, String toName, OtpInputStream paybuf)
 {
     tag         = regSendTag;
     this.from   = from;
     this.toName = toName;
     to          = null;
     this.paybuf = paybuf;
     payload     = null;
 }
Example #17
0
        public OtpErlangPid(OtpLocalNode self)
        {
            OtpErlangPid p = self.createPid();

            id       = p.id;
            serial   = p.serial;
            creation = p.creation;
            node     = p.node;
        }
Example #18
0
        /**
         * Create an Erlang PID from a stream containing a PID encoded in Erlang
         * external format.
         *
         * @param buf
         *                the stream containing the encoded PID.
         *
         * @exception OtpErlangDecodeException
         *                    if the buffer does not contain a valid external
         *                    representation of an Erlang PID.
         */
        public OtpErlangPid(OtpInputStream buf)
        {
            OtpErlangPid p = buf.read_pid();

            node     = p.Node;
            id       = p.Id;
            serial   = p.Serial;
            creation = p.Creation;
        }
Example #19
0
 // send has receiver pid but no sender information
 internal OtpMsg(OtpErlangPid to, OtpErlangObject payload)
 {
     tag          = sendTag;
     from         = null;
     this.to      = to;
     toName       = null;
     paybuf       = null;
     this.payload = payload;
 }
Example #20
0
 // send_reg has sender pid and receiver name
 internal OtpMsg(OtpErlangPid from, String toName, OtpErlangObject payload)
 {
     tag          = regSendTag;
     this.from    = from;
     this.toName  = toName;
     to           = null;
     paybuf       = null;
     this.payload = payload;
 }
Example #21
0
 // send has receiver pid but no sender information
 internal OtpMsg(OtpErlangPid to, OtpInputStream paybuf)
 {
     tag         = sendTag;
     from        = null;
     this.to     = to;
     toName      = null;
     this.paybuf = paybuf;
     payload     = null;
 }
Example #22
0
 /*
  * this one called explicitely by user code => use exit2
  */
 public void exit2(OtpErlangPid from, OtpErlangPid to, OtpErlangObject reason)
 {
     try
     {
         base.sendExit2(from, to, reason);
     }
     catch (Exception)
     {
     }
 }
Example #23
0
 public void AddLink(OtpErlangPid local, OtpErlangPid remote)
 {
     lock (lockObj)
     {
         Link l = Find(local, remote);
         if (l == null)
         {
             links.Add(new Link(local, remote));
         }
     }
 }
Example #24
0
 public void RemoveLink(OtpErlangPid local, OtpErlangPid remote)
 {
     lock (lockObj)
     {
         Link l = Find(local, remote);
         if (l != null)
         {
             links.Remove(l);
         }
     }
 }
Example #25
0
 public OtpErlangFun(OtpErlangPid pid, string module, long index, long uniq, IOtpErlangObject[] freeVars)
 {
     Pid      = pid;
     Module   = module;
     Arity    = -1;
     Md5      = null;
     Index    = index;
     OldIndex = 0;
     Uniq     = uniq;
     FreeVars = freeVars;
 }
Example #26
0
 public OtpErlangFun(OtpErlangPid pid, string module, int arity, byte[] md5, long index, long old_index, long uniq, IOtpErlangObject[] freeVars)
 {
     Pid      = pid;
     Module   = module;
     Arity    = arity;
     Md5      = md5;
     Index    = index;
     OldIndex = old_index;
     Uniq     = uniq;
     FreeVars = freeVars;
 }
Example #27
0
            public OtpMbox create(bool sync)
            {
                OtpErlangPid pid = node.createPid();
                OtpMbox      m   = sync ? new OtpMbox(node, pid) : new OtpActorMbox(sched, node, pid);

                lock (this)
                {
                    byPid.Add(pid, new WeakReference(m));
                }
                return(m);
            }
Example #28
0
        // other message types (link, unlink)
        internal OtpMsg(int tag, OtpErlangPid from, OtpErlangPid to)
        {
            // convert TT-tags to equiv non-TT versions
            if (tag > 10)
            {
                tag -= 10;
            }

            this.tag  = tag;
            this.from = from;
            this.to   = to;
        }
Example #29
0
 public OtpErlangFun(OtpInputStream buf)
 {
     OtpErlangFun f = buf.read_fun();
     pid = f.pid;
     module = f.module;
     arity = f.arity;
     md5 = f.md5;
     index = f.index;
     old_index = f.old_index;
     uniq = f.uniq;
     freeVars = f.freeVars;
 }
Example #30
0
 public OtpErlangFun(OtpErlangPid pid, String module,
                     long index, long uniq, OtpErlangObject[] freeVars)
 {
     this.pid      = pid;
     this.module   = module;
     arity         = -1;
     md5           = null;
     this.index    = index;
     old_index     = 0;
     this.uniq     = uniq;
     this.freeVars = freeVars;
 }
Example #31
0
        /**
         * Determine if two PIDs are equal. PIDs are equal if their components are
         * equal.
         *
         * @param port
         *                the other PID to compare to.
         *
         * @return true if the PIDs are equal, false otherwise.
         */
        public override bool Equals(Object o)
        {
            if (!(o is OtpErlangPid))
            {
                return(false);
            }

            OtpErlangPid pid = (OtpErlangPid)o;

            return(creation == pid.creation && serial == pid.serial && id == pid.id &&
                   node == pid.node);
        }
Example #32
0
 public OtpErlangFun(OtpErlangPid pid, String module,
             long index, long uniq, OtpErlangObject[] freeVars)
 {
     this.pid = pid;
     this.module = module;
     arity = -1;
     md5 = null;
     this.index = index;
     old_index = 0;
     this.uniq = uniq;
     this.freeVars = freeVars;
 }
Example #33
0
 public OtpErlangFun(OtpErlangPid pid, String module,
             int arity, byte[] md5, int index,
             long old_index, long uniq,
             OtpErlangObject[] freeVars)
 {
     this.pid = pid;
     this.module = module;
     this.arity = arity;
     this.md5 = md5;
     this.index = index;
     this.old_index = old_index;
     this.uniq = uniq;
     this.freeVars = freeVars;
 }
Example #34
0
 public void addLink(OtpErlangPid local, OtpErlangPid remote)
 {
     lock (this)
     {
         if (find(local, remote) == -1)
         {
             if (count >= links.Length)
             {
                 Link[] tmp = new Link[count * 2];
                 Array.Copy(links, 0, tmp, 0, count);
                 links = tmp;
             }
             links[count++] = new Link(local, remote);
         }
     }
 }
Example #35
0
 public int find(OtpErlangPid local, OtpErlangPid remote)
 {
     lock (this)
     {
         for (int i = 0; i < count; i++)
         {
             if (links[i].equals(local, remote))
             {
                 return i;
             }
         }
         return -1;
     }
 }
Example #36
0
 public bool exists(OtpErlangPid local, OtpErlangPid remote)
 {
     lock (this)
     {
         return find(local, remote) != -1;
     }
 }
 public void write_fun(OtpErlangPid pid, String module,
               long old_index, int arity, byte[] md5,
               long index, long uniq, OtpErlangObject[] freeVars)
 {
     if (arity == -1)
     {
         write1(OtpExternal.funTag);
         write4BE(freeVars.Length);
         pid.encode(this);
         write_atom(module);
         write_long(index);
         write_long(uniq);
         foreach (OtpErlangObject fv in freeVars)
         {
             fv.encode(this);
         }
     }
     else
     {
         write1(OtpExternal.newFunTag);
         int saveSizePos = getPos();
         write4BE(0); // this is where we patch in the size
         write1(arity);
         writeN(md5);
         write4BE(index);
         write4BE(freeVars.Length);
         write_atom(module);
         write_long(old_index);
         write_long(uniq);
         pid.encode(this);
         foreach (OtpErlangObject fv in freeVars)
         {
             fv.encode(this);
         }
         poke4BE(saveSizePos, getPos() - saveSizePos);
     }
 }
 // send has receiver pid but no sender information
 internal OtpMsg(OtpErlangPid to, OtpErlangObject payload)
 {
     tag = sendTag;
     from = null;
     this.to = to;
     toName = null;
     paybuf = null;
     this.payload = payload;
 }
        /**
         * Send a pre-encoded message to a process on a remote node.
         *
         * @param dest
         *            the Erlang PID of the remote process.
         * @param msg
         *            the encoded message to send.
         *
         * @exception java.io.IOException
         *                if the connection is not active or a communication error
         *                occurs.
         */
        protected void sendBuf(OtpErlangPid from, OtpErlangPid dest, OtpOutputStream payload)
        {
            if (!connected)
            {
                throw new IOException("Not connected");
            }
            OtpOutputStream header = new OtpOutputStream(headerLen);

            // preamble: 4 byte length + "passthrough" tag + version
            header.write4BE(0); // reserve space for length
            header.write1(passThrough);
            header.write1(version);

            // header info
            header.write_tuple_head(3);
            header.write_long(sendTag);
            if (sendCookie)
            {
                header.write_atom(self.Cookie);
            }
            else
            {
                header.write_atom("");
            }
            header.write_any(dest);

            // version for payload
            header.write1(version);

            // fix up length in preamble
            header.poke4BE(0, header.size() + payload.size() - 4);

            do_send(header, payload);
        }
 /**
  * Create an OtpErlangExit exception with the given reason and sender pid.
  *
  * @param reason
  *                the reason this exit signal has been sent.
  *
  * @param pid
  *                the pid that sent this exit.
  */
 public OtpErlangExit(OtpErlangObject reason, OtpErlangPid pid)
     : base(reason.ToString())
 {
     this.reason = reason;
     this.pid = pid;
 }
 // send_reg has sender pid and receiver name
 internal OtpMsg(OtpErlangPid from, String toName, OtpInputStream paybuf)
 {
     tag = regSendTag;
     this.from = from;
     this.toName = toName;
     to = null;
     this.paybuf = paybuf;
     payload = null;
 }
 // send_reg has sender pid and receiver name
 internal OtpMsg(OtpErlangPid from, String toName, OtpErlangObject payload)
 {
     tag = regSendTag;
     this.from = from;
     this.toName = toName;
     to = null;
     paybuf = null;
     this.payload = payload;
 }
 // exit (etc) has from, to, reason
 internal OtpMsg(int tag, OtpErlangPid from, OtpErlangPid to, OtpErlangObject reason)
 {
     this.tag = tag;
     this.from = from;
     this.to = to;
     paybuf = null;
     payload = reason;
 }
Example #44
0
 /* all remote pids get notified about failed pid */
 public OtpErlangPid[] remotePids()
 {
     lock (this)
     {
         OtpErlangPid[] ret = null;
         if (count != 0)
         {
             ret = new OtpErlangPid[count];
             for (int i = 0; i < count; i++)
             {
                 ret[i] = links[i].Remote;
             }
         }
         return ret;
     }
 }
Example #45
0
        public void removeLink(OtpErlangPid local, OtpErlangPid remote)
        {
            lock (this)
            {
                int i;

                if ((i = find(local, remote)) != -1)
                {
                    count--;
                    links[i] = links[count];
                    links[count] = null;
                }
            }
        }
 /*
  * snoop for outgoing unlinks and update own table
  */
 public void unlink(OtpErlangPid from, OtpErlangPid to)
 {
     lock (this)
     {
         links.removeLink(from, to);
         try
         {
             base.sendUnlink(from, to);
         }
         catch (IOException)
         {
         }
     }
 }
 /**
  * <p>
  * Equivalent to <code>OtpErlangExit(new OtpErlangAtom(reason),
  * pid)</code>.
  * </p>
  *
  * @param reason
  *                the reason this exit signal has been sent.
  *
  * @param pid
  *                the pid that sent this exit.
  *
  * @see #OtpErlangExit(OtpErlangObject, OtpErlangPid)
  */
 public OtpErlangExit(String reason, OtpErlangPid pid)
     : this(new OtpErlangAtom(reason), pid)
 {
 }
 /*
  * this one called explicitely by user code => use exit2
  */
 public void exit2(OtpErlangPid from, OtpErlangPid to, OtpErlangObject reason)
 {
     try
     {
         base.sendExit2(from, to, reason);
     }
     catch (Exception)
     {
     }
 }
        /**
         * Create an Erlang {@link OtpErlangPid pid}. Erlang pids are based upon
         * some node specific information; this method creates a pid using the
         * information in this node. Each call to this method produces a unique pid.
         *
         * @return an Erlang pid.
         */
        public OtpErlangPid createPid()
        {
            lock (this)
            {
                OtpErlangPid p = new OtpErlangPid(base.Node, pidCount, serial, base.Creation);

                pidCount++;
                if (pidCount > 0x7fff)
                {
                    pidCount = 0;

                    serial++;
                    if (serial > 0x1fff) /* 13 bits */
                    {
                        serial = 0;
                    }
                }

                return p;
            }
        }
Example #50
0
            /*
             * look up a mailbox based on its pid. If the mailbox has gone out of
             * scope we also remove the reference from the hashtable so we don't
             * find it again.
             */
            public OtpMbox get(OtpErlangPid pid)
            {
                lock (this)
                {
                    if (byPid.ContainsKey(pid))
                    {
                        WeakReference wr = byPid[pid];
                        OtpMbox m = (OtpMbox)wr.Target;

                        if (m != null)
                        {
                            return m;
                        }
                        byPid.Remove(pid);
                    }
                    return null;
                }
            }
 /*
  * send to remote name dest is recipient's registered name, the nodename is
  * implied by the choice of connection.
  */
 public void send(OtpErlangPid from, String dest, OtpErlangObject msg)
 {
     // encode and send the message
     sendBuf(from, dest, new OtpOutputStream(msg));
 }
 /**
  * Send an exit signal to a remote process.
  *
  * @param dest
  *            the Erlang PID of the remote process.
  * @param reason
  *            an Erlang term describing the exit reason.
  *
  * @exception java.io.IOException
  *                if the connection is not active or a communication error
  *                occurs.
  */
 protected void sendExit2(OtpErlangPid from, OtpErlangPid dest, OtpErlangObject reason)
 {
     sendExit(exit2Tag, from, dest, reason);
 }
 /*
  * snoop for outgoing links and update own table
  */
 public void link(OtpErlangPid from, OtpErlangPid to)
 {
     lock (this)
     {
         try
         {
             base.sendLink(from, to);
             links.addLink(from, to);
         }
         catch (IOException)
         {
             throw new OtpErlangExit("noproc", to);
         }
     }
 }
        // other message types (link, unlink)
        internal OtpMsg(int tag, OtpErlangPid from, OtpErlangPid to)
        {
            // convert TT-tags to equiv non-TT versions
            if (tag > 10)
            {
                tag -= 10;
            }

            this.tag = tag;
            this.from = from;
            this.to = to;
        }
        private void sendExit(int tag, OtpErlangPid from, OtpErlangPid dest, OtpErlangObject reason)
        {
            if (!connected)
            {
                throw new IOException("Not connected");
            }
            OtpOutputStream header = new OtpOutputStream(headerLen);

            // preamble: 4 byte length + "passthrough" tag
            header.write4BE(0); // reserve space for length
            header.write1(passThrough);
            header.write1(version);

            // header
            header.write_tuple_head(4);
            header.write_long(tag);
            header.write_any(from);
            header.write_any(dest);
            header.write_any(reason);

            // fix up length in preamble
            header.poke4BE(0, header.size() - 4);

            do_send(header);
        }
 // send has receiver pid but no sender information
 internal OtpMsg(OtpErlangPid to, OtpInputStream paybuf)
 {
     tag = sendTag;
     from = null;
     this.to = to;
     toName = null;
     this.paybuf = paybuf;
     payload = null;
 }
Example #57
0
        public static OtpErlangTuple Load(OtpMbox mbox, OtpErlangPid pid, string script)
        {
            OtpErlangObject body;
            OtpErlangBoolean debug = new OtpErlangBoolean(false);
            OtpErlangObject message;

            if (script.Length <= 65535)
            {
                body = new OtpErlangString(script);
            }
            else
            {
                body = new OtpErlangBinary(System.Text.Encoding.GetEncoding("iso-8859-1").GetBytes(script));
            }
            message = new OtpErlangTuple(new OtpErlangObject[] { mbox.Self, new OtpErlangAtom("load"), body, debug });

            mbox.send(pid, message);
            OtpErlangTuple reply = (OtpErlangTuple)mbox.receive();
            Console.WriteLine("Load: {0}", reply);

            return reply;
        }
 // special case when reason is an atom (i.e. most of the time)
 internal OtpMsg(int tag, OtpErlangPid from, OtpErlangPid to, String reason)
 {
     this.tag = tag;
     this.from = from;
     this.to = to;
     paybuf = null;
     payload = new OtpErlangAtom(reason);
 }
Example #59
0
        public OtpSelf(String node, String cookie, int port)
            : base(node, cookie)
        {
            sock = new TcpListener(new IPEndPoint(IPAddress.Any, port));
            sock.Start();

            if (port != 0)
            {
                this.port = port;
            }
            else
            {
                this.port = ((IPEndPoint)sock.LocalEndpoint).Port;
            }
            pid = createPid();
        }
        // this function used internally when "process" dies
        // since Erlang discerns between exit and exit/2.
        private void exit(int arity, OtpErlangPid to, OtpErlangObject reason)
        {
            try
            {
                String node = to.Node;
                if (node.Equals(home.Node))
                {
                    home.deliver(new OtpMsg(OtpMsg.exitTag, self, to, reason));
                }
                else
                {
                    OtpCookedConnection conn = home.getConnection(node);
                    if (conn == null)
                    {
                        return;
                    }
                    switch (arity)
                    {
                        case 1:
                            conn.exit(self, to, reason);
                            break;

                        case 2:
                            conn.exit2(self, to, reason);
                            break;
                    }
                }
            }
            catch (Exception)
            {
            }
        }