|Home >> All >> edu >> mit >> media|
AgentImpl: Base class for Hive agent implementations. An agent has a life cycle. Once in its lifetime, the agent is constructed by the no argument constructor. The agent arrives on a server; its doLocalSetup() method is called. This happens whenever it first comes to a server, whether created by Cell.createNewAgent(Class) or when it moves to the server. The agent's doBehavior() method is called. This method is the agent's main loop, where it's behavior is implemented. The agent is free to do what it wants, but should respect timeToStop . The agent sould never exit this method, a convienience method waitUntilDeath ...
CellAddress: This immutable class represents the URL of a Hive Cell. The protocol portion of the url is defined to be "hive", and will not allow the construction of urls with a different protocol. CellAddress follows the CISS (Common Internet Scheme Standard) Spec, although currently the file and ref portions of the URL are not used by the Hive system. WARNING: Java deviates from it's spec (at least on windows) in the DNS lookup behavior. Doing a InetAdderss.getByName(host).getHostName() does NOT return the fully qualified hostname as it should. Rather, some wierd caching behavior is causing the original argument ...
IconicUIAgentImpl: The UIAgent for a boxes and lines style GUI. BUGS: - Test this (from uiCanvas): Let the Canvas know it shouldn't start any new renders, as its agent is being killed. This might only be necessary because of the IcUIAg icon hack, test later. - A monitors B, A goes down, A comes back up, A tries to monitor B again, B throws rmi errors (problem with rmi, but might be possible to do a workaround). (not me, not raffi, sun.) - A monitors B, A kills self, A throws null. OR EVEN A monitors B, A stops monitoring B, A kills self, A throws null. (not me) - IcUIAg stops monitoring its own cell, then AWTUI kills ...
CellListAgentImpl: An agent that keeps a list of servers. Agents are in two flavours: a "master" agent that broadcasts events to whomever cares to listen, and "client" agents that subscribe to masters to track who is up or down. Eventually, the distinction between masters and clients might disappear, to make a more decentralized system. The agent sends events telling subscribers when servers are coming up or going down. Typically, only the master agent will be subscribed to. However, the slave agents can also rebroadcast these events, but -only- to other local agents The agent receives events from AgentMonitoringAgents ...
EventReceivingDescription: this interface is used so the event receiving agent can list the objects that it can respond to best. event receiving agents are supposed to be designed so they can repsond to any generic event, and then take special notice of certain events (ie -- string display agents will display whatever event they will get mouse events, etc, etc -- but it will display a string if it gets a string. so the String object is a specific event that the StringDisplayAgentImpl can handle. so this interface allows agent authors to list the objects that it can specially handle. this information is not stuck in the Description ...
EventSendingHelper: Helper class for EventSendingAgent interface; agent implementations can delegate methods to this class. This class maintains a list of listeners for events, as well as a count of events it has sent. When broadcastEvent is called by the client, the EventSendingHelper delivers the message to all current listeners. By default these messages are sent asynchronously. Please be careful if creating Hive objects to send by hand -- use the getCount() method in this object to determine the value that the count field in the HiveEvent constructor can use. This is not the recommended way to send events -- it ...
AsyncCaller: This is the default implementation of the asynchronous caller. It first creates the AsyncResult object, then spawns a thread which will do the asynchronous call. If the delay time passed to the watching thread is non-negative, it will spin off another thread which will sleep for a specified amount of time. If the calling thread does not complete before the watching thread, then it is killed and the AsyncResult will contain an AsyncCallNotCompleteException. This class is implemented as a singleton because there is no need to have more than one object at a time running.
Debug: The Debug class implements a simple debugging facility. Debugging messages are sent using one of the println methods, which are then sent out the debugging stream (by default, System.err ). Messages are tagged with a debugging level; if the message is less serious than the current debugging level, then the message is not printed. Hive code should use this facility for all debugging messages. The default debug level is NOTICE . Note: the class is entirely static, you should not instantiate it.
CellAgent: This interface is used to tag those agents which are "privledged". The reason this is used is for the session management support. When the AgentGraph records the agents which are in the system, it will inevitably record the UIManagerAgent and the CellListAgent. These will be restored by the Cell itself, so the SerializingAgentGraph has to realize which ones it should not restore . I'm assuming (I'm hoping I'm right), is that only one type of a "privledged" agent will be active on a server at one time. Please tell me if I'm wrong.
AutoMonitoringAgentImpl: this agent's sole purpose is to ask the agent monitoring agent to monitor any servers which have appeared on the scene (as according to the server list agent). this works by having this agent subscribe to the local server list agent and whenever it gets a message that a server goes up, it will ask the agent monitoring agent to monitor it. if a cell goes down or withdraws, then it will ask the agent monitoring agent to stop monitoring it
BaseUIAgentImpl: the standard base class for all ui agents -- this class will handle the minimum amount of state maintainance, and it will also handles a lot of the communications to the agent monitoring agents todo list -- the ability to monitor less cells than the agent monitoring agent is monitoring -- this would require that we filter the information the agent monitoring agent is sending and we need to keep track of exactly who we are monitoring
SerializableImage: Each instance of this class represents an image stored as an array of ints. These images are not AWT images - they are device independent images that can be serialized. They can be created from AWT Images, or from subclasses such as PPM that read from files. The format is an array of integers - each integer is a pixel in ARGB format (the same that MemoryImageSource uses in the default color model).
CellEvent: This is the event data for the server event -- it is designed to be able to be remitted. The case in which this becomes important is when then CellEventMonitor first creates this -- it will get a different sender and count code. These codes will be changed when they hit the agent that emits them, but the superclass will still contain the original code
GenericFilterAgentImpl: This abstract class is the superclass for all image filters. Subclassers need merely to implement the abstract filter method to have a working filter. It is very important that filter return a NEW image, and not merely a modified copy of the argument, or else there will be a lot of issues with multiple agents sharing copies of the same image.
BaseAWTGUIDisplayCellListButtonFrame: this class pops up a frame that has the servers listed in a choice field and then a button -- whatever extends this class can set what the title of the frame is, what the button label says, and the action performed when the button is pushed. right now this class is used for the shut down server and the stop monitoring server boxes
BaseSwingGUIDisplayCellListButtonFrame: this class pops up a frame that has the servers listed in a choice field and then a button -- whatever extends this class can set what the title of the frame is, what the button label says, and the action performed when the button is pushed. right now this class is used for the shut down server and the stop monitoring server boxes
GraphDifferenceHelper: this is a class of static methods which are just useful to help out when we need to know the "difference" between two graphs. this will help us tell the list of agents which have disappeared, the list of agents that have been added, the list of connections that have disappeared, and the list of connections that have been added
MobileAgentInputStream: A class that handles codebase annotation to do mobile agents. This class is currently buggy - managing ClassLoader namespace issues is proving to be difficult. Also, this class needs to deal with buffering the class bytes somehow, in case the agent wants to hop again. We need to implement our own class loader to manage things.
MovingAverageAgentImpl: Chaining agent - takes in event input from an agent, produces a time average. This has two parameters - how many milliseconds to remember, and how many milliseconds to average over. If historyLength is 300000 and averageWindow is 10000, then what we get is a 5 minute moving average of the number of events per 10 seconds.
HiveNotifyCall: this is just a different notify call that we use instead of the standard async one so we do not have to go through java reflection every time -- if we do have to go through that, things are going to get butt slow when just sending a lot of "notify"s. so this let's us send notifies without having to go through reflection
PPM: Each instance of this class represents an image stored as an array of ints in ARGB format. PPMs can be constructed from images, or more often from files or inputstreams in PPM format. Although this library can decode any bit depth from 1 - 24 per pixel, it always writes in 24 bits per pixel.
ImageDisplayAgentImpl: This agent provides a panel that displays any images it receives. When it gets a pending notification, it grays out the current image, and then when the image arrives it displays it. It centers the image and also doubles the size if it can do so without cutting off the image.
ConnectAgentHelper: Helper class for ConnectAgentHelper interface; agent implementations can delegate methods to this class. This class handles automatic wiring of an agent to and from other agents. Biggest thing still to do: add semantic criteria as well as the syntactic
AgentConnectCellEvent: This encapsulates an agent connect server event. Usually, the sourceAddress and the destinationAddrses are null as set by the CellEventMonitor. When the AgentMonitoringAgent rebroadcasts these events out -- it will set these appropriatly from its cache
AgentDisconnectCellEvent: This encapsulates an agent connect server event. Usually, the sourceAddress and the destinationAddrses are null as set by the CellEventMonitor. When the AgentMonitoringAgent rebroadcasts these events out -- it will set these appropriatly from its cache