llmediaplugins first step

1 files changed, 714 insertions, 0 deletions

diff --git a/linden/indra/llplugin/llpluginprocessparent.cpp b/linden/indra/llplugin/llpluginprocessparent.cpp
new file mode 100644
index 0000000..bd36d11
--- /dev/null
+++ b/linden/indra/llplugin/llpluginprocessparent.cpp
@@ -0,0 +1,714 @@
+/** 
+ * @file llpluginprocessparent.cpp
+ * @brief LLPluginProcessParent handles the parent side of the external-process plugin API.
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "llpluginprocessparent.h"
+#include "llpluginmessagepipe.h"
+#include "llpluginmessageclasses.h"
+
+#include "llapr.h"
+
+//virtual 
+LLPluginProcessParentOwner::~LLPluginProcessParentOwner()
+{
+        
+}
+
+LLPluginProcessParent::LLPluginProcessParent(LLPluginProcessParentOwner *owner)
+{
+        mOwner = owner;
+        mBoundPort = 0;
+        mState = STATE_UNINITIALIZED;
+        mDisableTimeout = false;
+        mDebug = false;
+
+        mPluginLaunchTimeout = 60.0f;
+        mPluginLockupTimeout = 30.0f;
+        
+        // Don't start the timer here -- start it when we actually launch the plugin process.
+        mHeartbeat.stop();
+}
+
+LLPluginProcessParent::~LLPluginProcessParent()
+{
+        LL_DEBUGS("Plugin") << "destructor" << LL_ENDL;
+
+        // Destroy any remaining shared memory regions
+        sharedMemoryRegionsType::iterator iter;
+        while((iter = mSharedMemoryRegions.begin()) != mSharedMemoryRegions.end())
+        {
+                // destroy the shared memory region
+                iter->second->destroy();
+                
+                // and remove it from our map
+                mSharedMemoryRegions.erase(iter);
+        }
+        
+        // orphaning the process means it won't be killed when the LLProcessLauncher is destructed.
+        // This is what we want -- it should exit cleanly once it notices the sockets have been closed.
+        mProcess.orphan();
+        killSockets();
+}
+
+void LLPluginProcessParent::killSockets(void)
+{
+        killMessagePipe();
+        mListenSocket.reset();
+        mSocket.reset();
+}
+
+void LLPluginProcessParent::errorState(void)
+{
+        if(mState < STATE_RUNNING)
+                setState(STATE_LAUNCH_FAILURE);
+        else
+                setState(STATE_ERROR);
+}
+
+void LLPluginProcessParent::init(const std::string &launcher_filename, const std::string &plugin_filename, bool debug, const std::string &user_data_path)
+{       
+        mProcess.setExecutable(launcher_filename);
+        mPluginFile = plugin_filename;
+        mCPUUsage = 0.0f;
+        mDebug = debug;
+        mUserDataPath = user_data_path;
+        
+        setState(STATE_INITIALIZED);
+}
+
+bool LLPluginProcessParent::accept()
+{
+        bool result = false;
+        
+        apr_status_t status = APR_EGENERAL;
+        apr_socket_t *new_socket = NULL;
+        
+        status = apr_socket_accept(
+                &new_socket,
+                mListenSocket->getSocket(),
+                gAPRPoolp);
+
+        
+        if(status == APR_SUCCESS)
+        {
+//              llinfos << "SUCCESS" << llendl;
+                // Success.  Create a message pipe on the new socket
+
+                // we MUST create a new pool for the LLSocket, since it will take ownership of it and delete it in its destructor!
+                apr_pool_t* new_pool = NULL;
+                status = apr_pool_create(&new_pool, gAPRPoolp);
+
+                mSocket = LLSocket::create(new_socket, new_pool);
+                new LLPluginMessagePipe(this, mSocket);
+
+                result = true;
+        }
+        else if(APR_STATUS_IS_EAGAIN(status))
+        {
+//              llinfos << "EAGAIN" << llendl;
+
+                // No incoming connections.  This is not an error.
+                status = APR_SUCCESS;
+        }
+        else
+        {
+//              llinfos << "Error:" << llendl;
+                ll_apr_warn_status(status);
+                
+                // Some other error.
+                errorState();
+        }
+        
+        return result;  
+}
+
+void LLPluginProcessParent::idle(void)
+{
+        bool idle_again;
+
+        do
+        {
+                // Give time to network processing
+                if(mMessagePipe)
+                {
+                        if(!mMessagePipe->pump())
+                        {
+//                              LL_WARNS("Plugin") << "Message pipe hit an error state" << LL_ENDL;
+                                errorState();
+                        }
+                }
+
+                if((mSocketError != APR_SUCCESS) && (mState <= STATE_RUNNING))
+                {
+                        // The socket is in an error state -- the plugin is gone.
+                        LL_WARNS("Plugin") << "Socket hit an error state (" << mSocketError << ")" << LL_ENDL;
+                        errorState();
+                }       
+                
+                // If a state needs to go directly to another state (as a performance enhancement), it can set idle_again to true after calling setState().
+                // USE THIS CAREFULLY, since it can starve other code.  Specifically make sure there's no way to get into a closed cycle and never return.
+                // When in doubt, don't do it.
+                idle_again = false;
+                switch(mState)
+                {
+                        case STATE_UNINITIALIZED:
+                        break;
+
+                        case STATE_INITIALIZED:
+                        {
+        
+                                apr_status_t status = APR_SUCCESS;
+                                apr_sockaddr_t* addr = NULL;
+                                mListenSocket = LLSocket::create(gAPRPoolp, LLSocket::STREAM_TCP);
+                                mBoundPort = 0;
+                                
+                                // This code is based on parts of LLSocket::create() in lliosocket.cpp.
+                                
+                                status = apr_sockaddr_info_get(
+                                        &addr,
+                                        "127.0.0.1",
+                                        APR_INET,
+                                        0,      // port 0 = ephemeral ("find me a port")
+                                        0,
+                                        gAPRPoolp);
+                                        
+                                if(ll_apr_warn_status(status))
+                                {
+                                        killSockets();
+                                        errorState();
+                                        break;
+                                }
+
+                                // This allows us to reuse the address on quick down/up. This is unlikely to create problems.
+                                ll_apr_warn_status(apr_socket_opt_set(mListenSocket->getSocket(), APR_SO_REUSEADDR, 1));
+                                
+                                status = apr_socket_bind(mListenSocket->getSocket(), addr);
+                                if(ll_apr_warn_status(status))
+                                {
+                                        killSockets();
+                                        errorState();
+                                        break;
+                                }
+
+                                // Get the actual port the socket was bound to
+                                {
+                                        apr_sockaddr_t* bound_addr = NULL;
+                                        if(ll_apr_warn_status(apr_socket_addr_get(&bound_addr, APR_LOCAL, mListenSocket->getSocket())))
+                                        {
+                                                killSockets();
+                                                errorState();
+                                                break;
+                                        }
+                                        mBoundPort = bound_addr->port;  
+
+                                        if(mBoundPort == 0)
+                                        {
+                                                LL_WARNS("Plugin") << "Bound port number unknown, bailing out." << LL_ENDL;
+                                                
+                                                killSockets();
+                                                errorState();
+                                                break;
+                                        }
+                                }
+                                
+                                LL_DEBUGS("Plugin") << "Bound tcp socket to port: " << addr->port << LL_ENDL;
+
+                                // Make the listen socket non-blocking
+                                status = apr_socket_opt_set(mListenSocket->getSocket(), APR_SO_NONBLOCK, 1);
+                                if(ll_apr_warn_status(status))
+                                {
+                                        killSockets();
+                                        errorState();
+                                        break;
+                                }
+
+                                apr_socket_timeout_set(mListenSocket->getSocket(), 0);
+                                if(ll_apr_warn_status(status))
+                                {
+                                        killSockets();
+                                        errorState();
+                                        break;
+                                }
+                                
+                                // If it's a stream based socket, we need to tell the OS
+                                // to keep a queue of incoming connections for ACCEPT.
+                                status = apr_socket_listen(
+                                        mListenSocket->getSocket(),
+                                        10); // FIXME: Magic number for queue size
+                                        
+                                if(ll_apr_warn_status(status))
+                                {
+                                        killSockets();
+                                        errorState();
+                                        break;
+                                }
+                                
+                                // If we got here, we're listening.
+                                setState(STATE_LISTENING);
+                        }
+                        break;
+                        
+                        case STATE_LISTENING:
+                        {
+                                // Launch the plugin process.
+                                
+                                // Only argument to the launcher is the port number we're listening on
+                                std::stringstream stream;
+                                stream << mBoundPort;
+                                mProcess.addArgument(stream.str());
+                                if(mProcess.launch() != 0)
+                                {
+                                        errorState();
+                                }
+                                else
+                                {
+                                        if(mDebug)
+                                        {
+                                                #if LL_DARWIN
+                                                // If we're set to debug, start up a gdb instance in a new terminal window and have it attach to the plugin process and continue.
+                                                
+                                                // The command we're constructing would look like this on the command line:
+                                                // osascript -e 'tell application "Terminal"' -e 'set win to do script "gdb -pid 12345"' -e 'do script "continue" in win' -e 'end tell'
+
+                                                std::stringstream cmd;
+                                                
+                                                mDebugger.setExecutable("/usr/bin/osascript");
+                                                mDebugger.addArgument("-e");
+                                                mDebugger.addArgument("tell application \"Terminal\"");
+                                                mDebugger.addArgument("-e");
+                                                cmd << "set win to do script \"gdb -pid " << mProcess.getProcessID() << "\"";
+                                                mDebugger.addArgument(cmd.str());
+                                                mDebugger.addArgument("-e");
+                                                mDebugger.addArgument("do script \"continue\" in win");
+                                                mDebugger.addArgument("-e");
+                                                mDebugger.addArgument("end tell");
+                                                mDebugger.launch();
+
+                                                #endif
+                                        }
+                                        
+                                        // This will allow us to time out if the process never starts.
+                                        mHeartbeat.start();
+                                        mHeartbeat.setTimerExpirySec(mPluginLaunchTimeout);
+                                        setState(STATE_LAUNCHED);
+                                }
+                        }
+                        break;
+
+                        case STATE_LAUNCHED:
+                                // waiting for the plugin to connect
+                                if(pluginLockedUpOrQuit())
+                                {
+                                        errorState();
+                                }
+                                else
+                                {
+                                        // Check for the incoming connection.
+                                        if(accept())
+                                        {
+                                                // Stop listening on the server port
+                                                mListenSocket.reset();
+                                                setState(STATE_CONNECTED);
+                                        }
+                                }
+                        break;
+                        
+                        case STATE_CONNECTED:
+                                // waiting for hello message from the plugin
+
+                                if(pluginLockedUpOrQuit())
+                                {
+                                        errorState();
+                                }
+                        break;
+
+                        case STATE_HELLO:
+                                LL_DEBUGS("Plugin") << "received hello message" << llendl;
+                                
+                                // Send the message to load the plugin
+                                {
+                                        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "load_plugin");
+                                        message.setValue("file", mPluginFile);
+                                        message.setValue("user_data_path", mUserDataPath);
+                                        sendMessage(message);
+                                }
+
+                                setState(STATE_LOADING);
+                        break;
+                        
+                        case STATE_LOADING:
+                                // The load_plugin_response message will kick us from here into STATE_RUNNING
+                                if(pluginLockedUpOrQuit())
+                                {
+                                        errorState();
+                                }
+                        break;
+                        
+                        case STATE_RUNNING:
+                                if(pluginLockedUpOrQuit())
+                                {
+                                        errorState();
+                                }
+                        break;
+                        
+                        case STATE_EXITING:
+                                if(!mProcess.isRunning())
+                                {
+                                        setState(STATE_CLEANUP);
+                                }
+                                else if(pluginLockedUp())
+                                {
+                                        LL_WARNS("Plugin") << "timeout in exiting state, bailing out" << llendl;
+                                        errorState();
+                                }
+                        break;
+
+                        case STATE_LAUNCH_FAILURE:
+                                if(mOwner != NULL)
+                                {
+                                        mOwner->pluginLaunchFailed();
+                                }
+                                setState(STATE_CLEANUP);
+                        break;
+
+                        case STATE_ERROR:
+                                if(mOwner != NULL)
+                                {
+                                        mOwner->pluginDied();
+                                }
+                                setState(STATE_CLEANUP);
+                        break;
+                        
+                        case STATE_CLEANUP:
+                                // Don't do a kill here anymore -- closing the sockets is the new 'kill'.
+                                mProcess.orphan();
+                                killSockets();
+                                setState(STATE_DONE);
+                        break;
+                        
+                        
+                        case STATE_DONE:
+                                // just sit here.
+                        break;
+                        
+                }
+        
+        } while (idle_again);
+}
+
+bool LLPluginProcessParent::isLoading(void)
+{
+        bool result = false;
+        
+        if(mState <= STATE_LOADING)
+                result = true;
+                
+        return result;
+}
+
+bool LLPluginProcessParent::isRunning(void)
+{
+        bool result = false;
+        
+        if(mState == STATE_RUNNING)
+                result = true;
+                
+        return result;
+}
+
+bool LLPluginProcessParent::isDone(void)
+{
+        bool result = false;
+        
+        if(mState == STATE_DONE)
+                result = true;
+                
+        return result;
+}
+
+void LLPluginProcessParent::setSleepTime(F64 sleep_time, bool force_send)
+{
+        if(force_send || (sleep_time != mSleepTime))
+        {
+                // Cache the time locally
+                mSleepTime = sleep_time;
+                
+                if(canSendMessage())
+                {
+                        // and send to the plugin.
+                        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "sleep_time");
+                        message.setValueReal("time", mSleepTime);
+                        sendMessage(message);
+                }
+                else
+                {
+                        // Too early to send -- the load_plugin_response message will trigger us to send mSleepTime later.
+                }
+        }
+}
+
+void LLPluginProcessParent::sendMessage(const LLPluginMessage &message)
+{
+        
+        std::string buffer = message.generate();
+        LL_DEBUGS("Plugin") << "Sending: " << buffer << LL_ENDL;        
+        writeMessageRaw(buffer);
+}
+
+
+void LLPluginProcessParent::receiveMessageRaw(const std::string &message)
+{
+        LL_DEBUGS("Plugin") << "Received: " << message << LL_ENDL;
+
+        // FIXME: should this go into a queue instead?
+        
+        LLPluginMessage parsed;
+        if(parsed.parse(message) != -1)
+        {
+                receiveMessage(parsed);
+        }
+}
+
+void LLPluginProcessParent::receiveMessage(const LLPluginMessage &message)
+{
+        std::string message_class = message.getClass();
+        if(message_class == LLPLUGIN_MESSAGE_CLASS_INTERNAL)
+        {
+                // internal messages should be handled here
+                std::string message_name = message.getName();
+                if(message_name == "hello")
+                {
+                        if(mState == STATE_CONNECTED)
+                        {
+                                // Plugin host has launched.  Tell it which plugin to load.
+                                setState(STATE_HELLO);
+                        }
+                        else
+                        {
+                                LL_WARNS("Plugin") << "received hello message in wrong state -- bailing out" << LL_ENDL;
+                                errorState();
+                        }
+                        
+                }
+                else if(message_name == "load_plugin_response")
+                {
+                        if(mState == STATE_LOADING)
+                        {
+                                // Plugin has been loaded. 
+                                
+                                mPluginVersionString = message.getValue("plugin_version");
+                                LL_INFOS("Plugin") << "plugin version string: " << mPluginVersionString << LL_ENDL;
+
+                                // Check which message classes/versions the plugin supports.
+                                // TODO: check against current versions
+                                // TODO: kill plugin on major mismatches?
+                                mMessageClassVersions = message.getValueLLSD("versions");
+                                LLSD::map_iterator iter;
+                                for(iter = mMessageClassVersions.beginMap(); iter != mMessageClassVersions.endMap(); iter++)
+                                {
+                                        LL_INFOS("Plugin") << "message class: " << iter->first << " -> version: " << iter->second.asString() << LL_ENDL;
+                                }
+                                
+                                // Send initial sleep time
+                                setSleepTime(mSleepTime, true);                 
+
+                                setState(STATE_RUNNING);
+                        }
+                        else
+                        {
+                                LL_WARNS("Plugin") << "received load_plugin_response message in wrong state -- bailing out" << LL_ENDL;
+                                errorState();
+                        }
+                }
+                else if(message_name == "heartbeat")
+                {
+                        // this resets our timer.
+                        mHeartbeat.setTimerExpirySec(mPluginLockupTimeout);
+
+                        mCPUUsage = message.getValueReal("cpu_usage");
+
+                        LL_DEBUGS("Plugin") << "cpu usage reported as " << mCPUUsage << LL_ENDL;
+                        
+                }
+                else if(message_name == "shm_add_response")
+                {
+                        // Nothing to do here.
+                }
+                else if(message_name == "shm_remove_response")
+                {
+                        std::string name = message.getValue("name");
+                        sharedMemoryRegionsType::iterator iter = mSharedMemoryRegions.find(name);
+                        
+                        if(iter != mSharedMemoryRegions.end())
+                        {
+                                // destroy the shared memory region
+                                iter->second->destroy();
+                                
+                                // and remove it from our map
+                                mSharedMemoryRegions.erase(iter);
+                        }
+                }
+                else
+                {
+                        LL_WARNS("Plugin") << "Unknown internal message from child: " << message_name << LL_ENDL;
+                }
+        }
+        else
+        {
+                if(mOwner != NULL)
+                {
+                        mOwner->receivePluginMessage(message);
+                }
+        }
+}
+
+std::string LLPluginProcessParent::addSharedMemory(size_t size)
+{
+        std::string name;
+        
+        LLPluginSharedMemory *region = new LLPluginSharedMemory;
+
+        // This is a new region
+        if(region->create(size))
+        {
+                name = region->getName();
+                
+                mSharedMemoryRegions.insert(sharedMemoryRegionsType::value_type(name, region));
+                
+                LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "shm_add");
+                message.setValue("name", name);
+                message.setValueS32("size", (S32)size);
+                sendMessage(message);
+        }
+        else
+        {
+                LL_WARNS("Plugin") << "Couldn't create a shared memory segment!" << LL_ENDL;
+
+                // Don't leak
+                delete region;
+        }
+
+        return name;
+}
+
+void LLPluginProcessParent::removeSharedMemory(const std::string &name)
+{
+        sharedMemoryRegionsType::iterator iter = mSharedMemoryRegions.find(name);
+        
+        if(iter != mSharedMemoryRegions.end())
+        {
+                // This segment exists.  Send the message to the child to unmap it.  The response will cause the parent to unmap our end.
+                LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "shm_remove");
+                message.setValue("name", name);
+                sendMessage(message);
+        }
+        else
+        {
+                LL_WARNS("Plugin") << "Request to remove an unknown shared memory segment." << LL_ENDL;
+        }
+}
+size_t LLPluginProcessParent::getSharedMemorySize(const std::string &name)
+{
+        size_t result = 0;
+        
+        sharedMemoryRegionsType::iterator iter = mSharedMemoryRegions.find(name);
+        if(iter != mSharedMemoryRegions.end())
+        {
+                result = iter->second->getSize();
+        }
+        
+        return result;
+}
+void *LLPluginProcessParent::getSharedMemoryAddress(const std::string &name)
+{
+        void *result = NULL;
+        
+        sharedMemoryRegionsType::iterator iter = mSharedMemoryRegions.find(name);
+        if(iter != mSharedMemoryRegions.end())
+        {
+                result = iter->second->getMappedAddress();
+        }
+        
+        return result;
+}
+
+std::string LLPluginProcessParent::getMessageClassVersion(const std::string &message_class)
+{
+        std::string result;
+        
+        if(mMessageClassVersions.has(message_class))
+        {
+                result = mMessageClassVersions[message_class].asString();
+        }
+        
+        return result;
+}
+
+std::string LLPluginProcessParent::getPluginVersion(void)
+{
+        return mPluginVersionString;
+}
+
+void LLPluginProcessParent::setState(EState state)
+{
+        LL_DEBUGS("Plugin") << "setting state to " << state << LL_ENDL;
+        mState = state; 
+};
+
+bool LLPluginProcessParent::pluginLockedUpOrQuit()
+{
+        bool result = false;
+        
+        if(!mDisableTimeout && !mDebug)
+        {
+                if(!mProcess.isRunning())
+                {
+                        LL_WARNS("Plugin") << "child exited" << llendl;
+                        result = true;
+                }
+                else if(pluginLockedUp())
+                {
+                        LL_WARNS("Plugin") << "timeout" << llendl;
+                        result = true;
+                }
+        }
+        
+        return result;
+}
+
+bool LLPluginProcessParent::pluginLockedUp()
+{
+        // If the timer is running and has expired, the plugin has locked up.
+        return (mHeartbeat.getStarted() && mHeartbeat.hasExpired());
+}
+