text:
//%2005////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation, The Open Group.
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// EMC Corporation; VERITAS Software Corporation; The Open Group.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//==============================================================================
//
// Author: Mike Brasher (mbrasher@bmc.com)
//
// Modified By: Mike Day (mdday@us.ibm.com)
//
// Modified By: Karl Schopmeyer (k.schopmeyer@opengroup.org)
//
// Modified By: Nag Boranna (nagaraja_boranna@hp.com)
//
// Modified By: Jenny Yu (jenny_yu@hp.com)
//
// Modified By: Sushma Fernandes (sushma_fernandes@hp.com)
//              Carol Ann Krug Graves, Hewlett-Packard Company
//                (carolann_graves@hp.com)
//      Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)
//
// Modified By: Dave Rosckes (rosckes@us.ibm.com)
//
// Modified By: Humberto Rivero (hurivero@us.ibm.com)
//
// Modified By: Steve Hills (steve.hills@ncr.com)
//              Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com)
//
// Modified By: Amit K Arora, IBM (amitarora@in.ibm.com) - pep 167
//
// Modified By: Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) - Bug#2555
//
// Modified By: Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) - Bug#2032
//
// Modified By: Heather Sterling, IBM (hsterl@us.ibm.com) - PEP#222
//
//%/////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////
//
// Notes on deamon operation (Unix) and service operation (Win 32):
//
// To run pegasus as a daemon on Unix platforms:
//
// cimserver
//
// To NOT run pegasus as a daemon on Unix platforms, set the daemon config
// property to false:
//
// cimserver daemon=false
//
// The daemon config property has no effect on windows operation.
//
// To shutdown pegasus, use the -s option:
//
// cimserver -s
//
// To run pegasus as an NT service, there are FOUR  different possibilities:
//
// To INSTALL the Pegasus service,
//
// cimserver -install
//
// To REMOVE the Pegasus service,
//
// cimserver -remove
//
// To START the Pegasus service,
//
// net start cimserver
// or
// cimserver -start
//
// To STOP the Pegasus service,
//
// net stop cimserver
// or
// cimserver -stop
//
// Alternatively, you can use the windows service manager. Pegasus shows up
// in the service database as "Pegasus CIM Object Manager"
//
// Mike Day, mdday@us.ibm.com
//
//////////////////////////////////////////////////////////////////////

#include <Pegasus/Common/Config.h>
#include <Pegasus/Common/Constants.h>
#include <iostream>
#include <cassert>
#include <cstdlib>
#include <fstream>
#include <Pegasus/Common/FileSystem.h>
#include <Pegasus/Common/Monitor.h>
#include <Pegasus/Common/PegasusVersion.h>
#include <Pegasus/Common/Logger.h>
#include <Pegasus/Common/System.h>
#include <Pegasus/Common/Tracer.h>
#include <Pegasus/Config/ConfigManager.h>
#include <Pegasus/Client/CIMClient.h>
#include <Pegasus/Server/ShutdownService.h>
#include <Pegasus/Server/CIMServer.h>
#include <Service/ServerProcess.h>

#if defined(PEGASUS_OS_OS400)
#  include "vfyptrs.cinc"
#  include "OS400ConvertChar.h"
#endif

PEGASUS_USING_PEGASUS;
PEGASUS_USING_STD;

#define PEGASUS_PROCESS_NAME "WMI Mapper";

//Windows service variables are not defined elsewhere in the product
//enable ability to override these
#ifndef PEGASUS_SERVICE_NAME
#define PEGASUS_SERVICE_NAME "Pegasus WMI Mapper";
#endif
#ifndef PEGASUS_SERVICE_DESCRIPTION
#define PEGASUS_SERVICE_DESCRIPTION "Pegasus WMI Mapper Service";
#endif

class CIMServerProcess : public ServerProcess
{
public:

    CIMServerProcess(void)
    {
        cimserver_set_process(this);
    }

    virtual ~CIMServerProcess(void)
    {
    }

    //defined in PegasusVersion.h
    virtual const char* getProductName() const
    {
        return PEGASUS_PRODUCT_NAME;
    }

    virtual const char* getExtendedName() const
    {
        return PEGASUS_SERVICE_NAME;
    }

    virtual const char* getDescription() const
    {
        return PEGASUS_SERVICE_DESCRIPTION;
    }

    //defined in PegasusVersion.h
    virtual const char* getVersion() const
    {
        return PEGASUS_PRODUCT_VERSION;
    }

    virtual const char* getProcessName() const
    {
        return PEGASUS_PROCESS_NAME;
    }

    //defined in ConfigFileDir.h
    virtual const char* getPIDFileName() const
    {
        return CIMSERVER_START_FILE;
    }

    int cimserver_run(int argc, char** argv, bool shutdownOption);

    void cimserver_stop(void);
};

AutoPtr<CIMServerProcess> _cimServerProcess(new CIMServerProcess());
static CIMServer* _cimServer = 0;
static Monitor* _monitor = 0;

//
//  The command name.
//
static const char COMMAND_NAME []    = "cimserver";

//
//  The constant defining usage string.
//
static const char USAGE []           = "Usage: ";

/**
Constants representing the command line options.
*/
static const char OPTION_VERSION     = 'v';

static const char OPTION_HELP        = 'h';

static const char OPTION_HOME        = 'D';

static const char OPTION_SHUTDOWN    = 's';

static const char   LONG_HELP []  = "help";

static const char   LONG_VERSION []  = "version";

#if defined(PEGASUS_OS_HPUX)
static const char OPTION_BINDVERBOSE = 'X';
#endif

static const String PROPERTY_TIMEOUT = "shutdownTimeout";

ConfigManager*    configManager;

/** GetOptions function - This function defines the Options Table
    and sets up the options from that table using the config manager.
*/
void GetOptions(
    ConfigManager* cm,
    int& argc,
    char** argv)
{
    try
    {
        cm->mergeConfigFiles();

        cm->mergeCommandLine(argc, argv);
    }
    catch (NoSuchFile&)
    {
        throw;
    }
    catch (FileNotReadable&)
    {
        throw;
    }
    catch (CannotRenameFile&)
    {
        throw;
    }
    catch (ConfigFileSyntaxError&)
    {
        throw;
    }
    catch(UnrecognizedConfigProperty&)
    {
        throw;
    }
    catch(InvalidPropertyValue&)
    {
        throw;
    }
    catch (CannotOpenFile&)
    {
        throw;
    }
}

/* PrintHelp - This is temporary until we expand the options manager to allow
   options help to be defined with the OptionRow entries and presented from
   those entries.
*/
void PrintHelp(const char* arg0)
{
    String usage = String (USAGE);
    usage.append (COMMAND_NAME);
    usage.append (" [ [ options ] | [ configProperty=value, ... ] ]\n");
    usage.append ("  options\n");
    usage.append ("    -v, --version   - displays CIM Server version number\n");
    usage.append ("    -h, --help      - prints this help message\n");
    usage.append ("    -s              - shuts down CIM Server\n");
#if !defined(PEGASUS_USE_RELEASE_DIRS)
    usage.append ("    -D [home]       - sets pegasus home directory\n");
#endif
#if defined(PEGASUS_OS_TYPE_WINDOWS)
    usage.append ("    -install [name] - installs pegasus as a Windows Service\n");
    usage.append ("                      [name] is optional and overrides the\n");
    usage.append ("                      default CIM Server Service Name\n");
    usage.append ("    -remove [name]  - removes pegasus as a Windows Service\n");
    usage.append ("                      [name] is optional and overrides the\n");
    usage.append ("                      default CIM Server Service Name\n");
    usage.append ("    -start [name]   - starts pegasus as a Windows Service\n");
    usage.append ("                      [name] is optional and overrides the\n");
    usage.append ("                      default CIM Server Service Name\n");
    usage.append ("    -stop [name]    - stops pegasus as a Windows Service\n");
    usage.append ("                      [name] is optional and overrides the\n");
    usage.append ("                      default CIM Server Service Name\n\n");
#endif
    usage.append ("  configProperty=value\n");
    usage.append ("                    - sets CIM Server configuration property\n");

    cout << endl;
    cout << _cimServerProcess->getProductName() << " " << _cimServerProcess->getVersion() << endl;
    cout << endl;

#if defined(PEGASUS_OS_TYPE_WINDOWS)
    MessageLoaderParms parms("src.Server.cimserver.MENU.WINDOWS", usage);
#elif defined(PEGASUS_USE_RELEASE_DIRS)
    MessageLoaderParms parms("src.Server.cimserver.MENU.HPUXLINUXIA64GNU", usage);
#else
    MessageLoaderParms parms("src.Server.cimserver.MENU.STANDARD", usage);
#endif
    cout << MessageLoader::getMessage(parms) << endl;
}

//This needs to be called at various points in the code depending on the platform and error conditions.
//We need to delete the _cimServer reference on exit in order for the destructors to get called.
void deleteCIMServer()
{
    if (_cimServer)
    {
        delete _cimServer;
        _cimServer = 0;
    }

	if (_monitor)
	{
		delete _monitor;
	}
}

// l10n
//
// Dummy function for the Thread object associated with the initial thread.
// Since the initial thread is used to process CIM requests, this is
// needed to localize the exceptions thrown during CIM request processing.
// Note: This function should never be called!
//
PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL dummyThreadFunc(void *parm)
{
   return((PEGASUS_THREAD_RETURN)0);
}

void shutdownCIMOM(Uint32 timeoutValue)
{
    //
    // Create CIMClient object
    //
    CIMClient client;

    //
    // Get local host name
    //
    String hostStr = System::getHostName();

    //
    // open connection to CIMOM
    //
    try
    {
        client.connectLocal();

        //
        // set client timeout to 2 seconds
        //
        client.setTimeout(2000);
    }
    catch(Exception&)
    {
#ifdef PEGASUS_OS_OS400
    //l10n
    //Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
            //"Unable to connect to CIM Server.  CIM Server may not be running." );
    Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
            "src.Server.cimserver.UNABLE_CONNECT_SERVER_MAY_NOT_BE_RUNNING",
            "Unable to connect to CIM Server.  CIM Server may not be running." );
    // The server job may still be active but not responding.
    // Kill the job if it exists.
    if(_cimServerProcess->cimserver_kill(0) == -1)
       _cimServerProcess->cimserver_exitRC(2);
    _cimServerProcess->cimserver_exitRC(1);
#else
        //l10n
        //PEGASUS_STD(cerr) << "Unable to connect to CIM Server." << PEGASUS_STD(endl);
        //PEGASUS_STD(cerr) << "CIM Server may not be running." << PEGASUS_STD(endl);
        MessageLoaderParms parms("src.Server.cimserver.UNABLE_CONNECT_SERVER_MAY_NOT_BE_RUNNING",
                                                         "Unable to connect to CIM Server.\nCIM Server may not be running.\n");
        PEGASUS_STD(cerr) << MessageLoader::getMessage(parms);
        exit(1);
#endif
    }

    try
    {
        //
        // construct CIMObjectPath
        //
        String referenceStr = "//";
        referenceStr.append(hostStr);
        referenceStr.append("/");
        referenceStr.append(PEGASUS_NAMESPACENAME_SHUTDOWN.getString());
        referenceStr.append(":");
        referenceStr.append(PEGASUS_CLASSNAME_SHUTDOWN.getString());
        CIMObjectPath reference(referenceStr);

        //
        // issue the invokeMethod request on the shutdown method
        //
        Array<CIMParamValue> inParams;
        Array<CIMParamValue> outParams;

        // set force option to true for now
        inParams.append(CIMParamValue("force",
            CIMValue(Boolean(true))));

        inParams.append(CIMParamValue("timeout",
            CIMValue(Uint32(timeoutValue))));

        CIMValue retValue = client.invokeMethod(
            PEGASUS_NAMESPACENAME_SHUTDOWN,
            reference,
            "shutdown",
            inParams,
            outParams);
    }
    catch(CIMException& e)
    {
#ifdef PEGASUS_OS_OS400

    if (e.getCode() == CIM_ERR_INVALID_NAMESPACE)
    {
        //l10n
        //Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
            //"Failed to shutdown server: $0", "The repository may be empty.");
        Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
            "src.Server.cimserver.SHUTDOWN_FAILED_REPOSITORY_EMPTY",
            "Error in server shutdown: The repository may be empty.");
    }
    else
    {
        //l10n
        //Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
            //"Failed to shutdown server: $0", e.getMessage());
        Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
            "src.Server.cimserver.SHUTDOWN_FAILED",
            "Error in server shutdown: $0", e.getMessage());
    }
    // Kill the server job.
    if(_cimServerProcess->cimserver_kill(0) == -1)
       _cimServerProcess->cimserver_exitRC(2);
#else
        //l10n - TODO
        MessageLoaderParms parms("src.Server.cimserver.SHUTDOWN_FAILED",
                                 "Error in server shutdown: ");
        PEGASUS_STD(cerr) << MessageLoader::getMessage(parms);
        if (e.getCode() == CIM_ERR_INVALID_NAMESPACE)
        {
            //
            // Repository may be empty.
            //
            //l10n - TODO
            Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                "src.Server.cimserver.SHUTDOWN_FAILED_REPOSITORY_EMPTY",
                "Error in server shutdown: The repository may be empty.");
            MessageLoaderParms parms("src.Server.cimserver.REPOSITORY_EMPTY",
                                     "The repository may be empty.");
            PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);
        }
        else
        {
            //l10n - TODO
            Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                "src.Server.cimserver.SHUTDOWN_FAILED",
                "Error in server shutdown: $0", e.getMessage());
            PEGASUS_STD(cerr) << e.getMessage() << PEGASUS_STD(endl);
        }

    // Kill the cimserver process
    if (_cimServerProcess->cimserver_kill(0) == 0)
        {
            //l10n - TODO
            Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                "src.Server.cimserver.SERVER_FORCED_SHUTDOWN",
            "Forced shutdown initiated.");
            MessageLoaderParms parms("src.Server.cimserver.SERVER_FORCED_SHUTDOWN",
                                     "Forced shutdown initiated.");
            PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);
        }
        exit(1);
#endif
    }
    catch(Exception&)
    {
        //
        // This may mean that the CIM Server has terminated, causing this
        // client to get a "Empty HTTP response message" exception.  It may
        // also mean that the CIM Server is taking longer than 2 seconds
        // (client timeout value) to terminate, causing this client to
        // timeout with a "connection timeout" exception.
        //
        // Check to see if CIM Server is still running.  If CIM Server
        // is still running and the shutdown timeout has not expired,
        // loop and wait one second until either the CIM Server is
        // terminated or timeout expires.  If timeout expires and
        // the CIM Server is still running, kill the CIMServer process.
        //
        Uint32 maxWaitTime = timeoutValue - 2;
        Boolean running = _cimServerProcess->isCIMServerRunning();
        while ( running && maxWaitTime > 0 )
        {
            System::sleep(1);
            running = _cimServerProcess->isCIMServerRunning();
            maxWaitTime = maxWaitTime - 1;
        }

        if (running)
        {
       int kill_rc = _cimServerProcess->cimserver_kill(0);

#ifdef PEGASUS_OS_OS400
        if(kill_rc == -1)
        _cimServerProcess->cimserver_exitRC(2);
        _cimServerProcess->cimserver_exitRC(1);
#endif

#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) \
|| defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_PLATFORM_SOLARIS_SPARC_CC) \
|| defined (PEGASUS_OS_VMS)
        if (kill_rc != -1)
            {
                //l10n - TODO
                Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                    "src.Server.cimserver.TIMEOUT_EXPIRED_SERVER_KILLED",
                    "Shutdown timeout expired.  Forced shutdown initiated.");
                MessageLoaderParms parms("src.Server.cimserver.TIMEOUT_EXPIRED_SERVER_KILLED",
                    "Shutdown timeout expired.  Forced shutdown initiated.");
                cout << MessageLoader::getMessage(parms) << endl;
                exit(0);
            }
#endif
        }
    }

    return;
}

/////////////////////////////////////////////////////////////////////////
//  MAIN
//////////////////////////////////////////////////////////////////////////
int main(int argc, char** argv)
{
    String pegasusHome  = String::EMPTY;
    Boolean shutdownOption = false;

//l10n
// Set Message loading to process locale
MessageLoader::_useProcessLocale = true;
//l10n

//l10n
#if defined(PEGASUS_OS_AIX) && defined(PEGASUS_HAS_MESSAGES)
setlocale(LC_ALL, "");
#endif

#ifdef PEGASUS_OS_OS400

  VFYPTRS_INCDCL;               // VFYPTRS local variables

  // verify pointers
  #pragma exception_handler (qsyvp_excp_hndlr,qsyvp_excp_comm_area,\
    0,_C2_MH_ESCAPE)
    for( int arg_index = 1; arg_index < argc; arg_index++ ){
    VFYPTRS(VERIFY_SPP_NULL(argv[arg_index]));
    }
  #pragma disable_handler

    // Convert the args to ASCII
    for(Uint32 i = 0;i< argc;++i)
    {
    EtoA(argv[i]);
    }

    // Initialize Pegasus home to the shipped OS/400 directory.
    pegasusHome = OS400_DEFAULT_PEGASUS_HOME;
#endif

#ifndef PEGASUS_OS_TYPE_WINDOWS
    //
    // Get environment variables:
    //
#ifdef PEGASUS_OS_OS400
#pragma convert(37)
    const char* tmp = getenv("PEGASUS_HOME");
#pragma convert(0)
    char home[256] = {0};
    if (tmp && strlen(tmp) < 256)
    {
    strcpy(home, tmp);
    EtoA(home);
    pegasusHome = home;
    }
#else
  #if defined(PEGASUS_OS_AIX) && defined(PEGASUS_USE_RELEASE_DIRS)
    pegasusHome = AIX_RELEASE_PEGASUS_HOME;
  #elif !defined(PEGASUS_USE_RELEASE_DIRS)
    const char* tmp = getenv("PEGASUS_HOME");

    if (tmp)
    {
        pegasusHome = tmp;
    }
  #endif
#endif

    FileSystem::translateSlashes(pegasusHome);
#else

  // windows only
  //setHome(pegasusHome);
  pegasusHome = _cimServerProcess->getHome();
#endif

        // Get help, version, and shutdown options

        for (int i = 1; i < argc; )
        {
            const char* arg = argv[i];
            if(String::equal(arg,"--help"))
            {
                    PrintHelp(argv[0]);
                    exit(0);
            }
            else if(String::equal(arg,"--version"))
            {
                cout << _cimServerProcess->getVersion() << endl;
                exit(0);
            }
            // Check for -option
            else if (*arg == '-')
            {
                // Get the option
                const char* option = arg + 1;

                //
                // Check to see if user asked for the version (-v option):
                //
                if (*option == OPTION_VERSION &&
                    strlen(option) == 1)
                {
                    cout << _cimServerProcess->getVersion() << endl;
                    exit(0);
                }
                //
                // Check to see if user asked for help (-h option):
                //
                else if (*option == OPTION_HELP &&
                        (strlen(option) == 1))
                {
                    PrintHelp(argv[0]);
                    exit(0);
                }
#if !defined(PEGASUS_USE_RELEASE_DIRS)
                else if (*option == OPTION_HOME &&
                        (strlen(option) == 1))
                {
                    if (i + 1 < argc)
                    {
                        pegasusHome.assign(argv[i + 1]);
                    }
                    else
                    {
                        //l10n
                        //cout << "Missing argument for option -" << option << endl;
                        String opt(option);
                        MessageLoaderParms parms("src.Server.cimserver.MISSING_ARGUMENT",
                                         "Missing argument for option -$0",
                                         opt);
                        cout << MessageLoader::getMessage(parms) << endl;
                        exit(0);
                    }

                    memmove(&argv[i], &argv[i + 2], (argc-i-1) * sizeof(char*));
                    argc -= 2;
                }
#endif
#if defined(PEGASUS_OS_HPUX)
                //
                // Check to see if user asked for the version (-X option):
                //
                if (*option == OPTION_BINDVERBOSE &&
                        (strlen(option) == 1))
                {
            System::bindVerbose = true;
                    //l10n
                    //cout << "Unsupported debug option, BIND_VERBOSE, enabled."
                         //<< endl;
                    MessageLoaderParms parms("src.Server.cimserver.UNSUPPORTED_DEBUG_OPTION",
                                         "Unsupported debug option, BIND_VERBOSE, enabled.");
                    cout << MessageLoader::getMessage(parms) << endl;
                    // remove the option from the command line
                    memmove(&argv[i], &argv[i + 1], (argc-i) * sizeof(char*));
                    argc--;
                }
#endif
                //
                // Check to see if user asked for shutdown (-s option):
                //
                else if (*option == OPTION_SHUTDOWN &&
                        (strlen(option) == 1))
                {
                    //
                    // Check to see if shutdown has already been specified:
                    //
                    if (shutdownOption)
                    {
                        //l10n
                        //cout << "Duplicate shutdown option specified." << endl;
                        MessageLoaderParms parms("src.Server.cimserver.DUPLICATE_SHUTDOWN_OPTION",
                                                 "Duplicate shutdown option specified.");

                        cout << MessageLoader::getMessage(parms) << endl;
                        exit(0);
                    }

                    shutdownOption = true;

                    // remove the option from the command line
                    memmove(&argv[i], &argv[i + 1], (argc-i) * sizeof(char*));
                    argc--;
                }
                else
                    i++;
            }
            else
                i++;
        }

    //
    // Set the value for pegasusHome property
    //
    ConfigManager::setPegasusHome(pegasusHome);

    //
    // Do the plaform specific run
    //

    return _cimServerProcess->platform_run( argc, argv, shutdownOption );
}

void CIMServerProcess::cimserver_stop()
{
    _cimServer->shutdownSignal();
}

//
// The main, common, running code
//
// NOTE: Do NOT call exit().  Use return(), otherwise some platforms
// will fail to shutdown properly/cleanly.
//
// TODO: Current change minimal for platform "service" shutdown bug fixes.
// Perhpas further extract out common stuff and put into main(), put
// daemon stuff into platform specific platform_run(), etc.
// Note: make sure to not put error handling stuff that platform
// specific runs may need to deal with bettter (instead of exit(), etc).
//

int CIMServerProcess::cimserver_run( int argc, char** argv, Boolean shutdownOption )
{
    String logsDirectory = String::EMPTY;
    Boolean daemonOption = false;

    //
    // Get an instance of the Config Manager.
    //
    configManager = ConfigManager::getInstance();
    configManager->useConfigFiles = true;

#ifdef PEGASUS_OS_OS400
    // In a special startup case for IBM OS400, when the server is
    // automatically started when the machine starts up the config
    // file cannot be read because of access restrictions for the
    // user starting the server.  In this case, we need to skip
    // reading the config options and therefore any use of the config
    // manager also.  To make this determinations we will check to see
    // if the daemon flag is set to true.  If so, then there will be a
    // series of checks to bracket all the calls to the configManager
    // which would otherwise fail.  All this will only be done for
    // IBM OS400.

    Boolean os400StartupOption = false;
    // loop through args to check for daemon=true
    for (int i=1; i < argc; i++)
      if (strcmp(argv[i], "daemon=true") == 0)
      {
        os400StartupOption = true;
        daemonOption = true;
      }
#endif

    //
    // Get options (from command line and from configuration file); this
    // removes corresponding options and their arguments from the command
    // line.
    //
    try
    {
#ifdef PEGASUS_OS_OS400
    if (os400StartupOption == false)
#endif
        GetOptions(configManager, argc, argv);
    }
    catch (Exception& e)
    {
        Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
            "src.Server.cimserver.SERVER_NOT_STARTED",
            "cimserver not started:  $0", e.getMessage());

#if !defined(PEGASUS_OS_OS400)
        MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED",
            "cimserver not started: $0", e.getMessage());

        PEGASUS_STD(cerr) << argv[0] << ": " << MessageLoader::getMessage(parms)
            << PEGASUS_STD(endl);
#endif

        return(1);
    }

// l10n
    // Set the home directory, msg sub-dir, into the MessageLoader.
    // This will be the default directory where the resource bundles
    // are found.
    MessageLoader::setPegasusMsgHome(ConfigManager::getHomedPath(
        ConfigManager::getInstance()->getCurrentValue("messageDir")));

#ifdef PEGASUS_OS_OS400
    // Still need to declare and set the connection variables.
    // Will initialize to false since they are fixed at false for OS400.

    // NOTE:  OS400 is a LOCAL_DOMAIN_SOCKET, so a few lines down
    // the test will not be compiled in.  If OS400 ever turns off that
    // define, then we will need to change this code path to insure that
    // one of the variables is true.
    Boolean enableHttpConnection = false;
    Boolean enableHttpsConnection = false;
    Boolean enableSSLExportClientVerification = false;

    if (os400StartupOption == false)
    {
      enableHttpConnection = String::equal(
          configManager->getCurrentValue("enableHttpConnection"), "true");
      enableHttpsConnection = String::equal(
          configManager->getCurrentValue("enableHttpsConnection"), "true");
      enableSSLExportClientVerification = String::equal(
          configManager->getCurrentValue("enableSSLExportClientVerification"), "true");
    }
#else
    Boolean enableHttpConnection = String::equal(
        configManager->getCurrentValue("enableHttpConnection"), "true");
    Boolean enableHttpsConnection = String::equal(
        configManager->getCurrentValue("enableHttpsConnection"), "true");
    Boolean enableSSLExportClientVerification = String::equal(
        configManager->getCurrentValue("enableSSLExportClientVerification"), "true");
#endif

    // Make sure at least one connection is enabled
#ifdef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
    if (!enableHttpConnection && !enableHttpsConnection)
    {
        //l10n
        //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
            //"Neither HTTP nor HTTPS connection is enabled.  "
            //"CIMServer will not be started.");
        Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
            "src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING",
            "Neither HTTP nor HTTPS connection is enabled.  CIMServer will not be started.");
        //cerr << "Neither HTTP nor HTTPS connection is enabled.  "
            //"CIMServer will not be started." << endl;
        MessageLoaderParms parms("src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING",
                                 "Neither HTTP nor HTTPS connection is enabled.  CIMServer will not be started.");
        cerr << MessageLoader::getMessage(parms) << endl;
        return(1);
    }
#endif

    try
    {
        //
        // Check to see if we should Pegasus as a daemon
        //

        if (String::equal(configManager->getCurrentValue("daemon"), "true"))
        {
            daemonOption = true;
        }

#ifdef PEGASUS_OS_OS400
    if (os400StartupOption == false)
    {
#endif
        // Get the log file directory definition.
        // We put String into Cstring because
        // Directory functions only handle Cstring.
        // ATTN-KS: create String based directory functions.

        logsDirectory = configManager->getCurrentValue("logdir");
        logsDirectory =
        ConfigManager::getHomedPath(configManager->getCurrentValue("logdir"));
#ifdef PEGASUS_OS_OS400
    }  // end if (os400StartupOption == false)
#endif

        // Set up the Logger. This does not open the logs
        // Might be more logical to clean before set.
        // ATTN: Need tool to completely disable logging.

#if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && \
!defined(PEGASUS_OS_OS400)
        Logger::setHomeDirectory(logsDirectory);
#endif

        //
        // Check to see if we need to shutdown CIMOM
        //
        if (shutdownOption)
        {
            String configTimeout =
                configManager->getCurrentValue("shutdownTimeout");
            Uint32 timeoutValue = strtol(configTimeout.getCString(), (char **)0, 10);

            shutdownCIMOM(timeoutValue);

#ifdef PEGASUS_OS_OS400
        //l10n
        //Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,
            //"CIM Server stopped.");
        Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,
            "src.Server.cimserver.SERVER_STOPPED",
            "CIM Server stopped.");
            cimserver_exitRC(0);
#else
            //l10n
            //cout << "CIM Server stopped." << endl;
            MessageLoaderParms parms("src.Server.cimserver.SERVER_STOPPED",
                                     "CIM Server stopped.");

            cout << MessageLoader::getMessage(parms) << endl;
            return(0);
#endif
        }

#if defined(PEGASUS_DEBUG)
        // Leave this in until people get familiar with the logs.
        //l10n
        //cout << "Logs Directory = " << logsDirectory << endl;
        MessageLoaderParms parms("src.Server.cimserver.LOGS_DIRECTORY",
                                 "Logs Directory = ");
        cout << MessageLoader::getMessage(parms) << logsDirectory << endl;
#endif
    }
    catch (UnrecognizedConfigProperty& e)
    {

#ifdef PEGASUS_OS_OS400
    //l10n
    //Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
            //"Error: $0",e.getMessage());
    Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
            "src.Server.cimserver.ERROR",
            "Error: $0",e.getMessage());
#else
    //l10n
    //cout << "Error: " << e.getMessage() << endl;
    MessageLoaderParms parms("src.Server.cimserver.ERROR",
                             "Error: $0",
                             e.getMessage());
    cout << MessageLoader::getMessage(parms) << endl;
#endif
    }

    // Bug 2148 - Here is the order of operations for determining the server HTTP and HTTPS ports.
    // 1) If the user explicitly specified a port, use it.
    // 2) If the user did not specify a port, get the port from the services file.
    // 3) If no value is specified in the services file, use the IANA WBEM default port.
    // Note that 2 and 3 are done within the System::lookupPort method
    // An empty string from the ConfigManager implies that the user did not specify a port.

    Uint32 portNumberHttps=0;
    Uint32 portNumberHttp=0;
    Uint32 portNumberExportHttps=0;

    if (enableHttpsConnection)
    {
        String httpsPort = configManager->getCurrentValue("httpsPort");
        if (httpsPort == String::EMPTY)
        {
            //
            // Look up the WBEM-HTTPS port number
            //
            portNumberHttps = System::lookupPort(WBEM_HTTPS_SERVICE_NAME, WBEM_DEFAULT_HTTPS_PORT);

        } else
        {
            //
            // user-specified
            //
            CString portString = httpsPort.getCString();
            char* end = 0;
            portNumberHttps = strtol(portString, &end, 10);
            if(!(end != 0 && *end == '\0'))
            {
                InvalidPropertyValue e("httpsPort", httpsPort);
                cerr << e.getMessage() << endl;
                exit(1);
            }
        }
    }

    if (enableHttpConnection)
    {
        String httpPort = configManager->getCurrentValue("httpPort");
        if (httpPort == String::EMPTY)
        {
            //
            // Look up the WBEM-HTTP port number
            //
            portNumberHttp = System::lookupPort(WBEM_HTTP_SERVICE_NAME, WBEM_DEFAULT_HTTP_PORT);

        } else
        {
            //
            // user-specified
            //
            CString portString = httpPort.getCString();
            char* end = 0;
            portNumberHttp = strtol(portString, &end, 10);
            if(!(end != 0 && *end == '\0'))
            {
                InvalidPropertyValue e("httpPort", httpPort);
                cerr << e.getMessage() << endl;
                exit(1);
            }
        }
    }

    if (enableSSLExportClientVerification)
    {
        //
        // No config property is looked up to get the default port number.
        // Lookup the port defined in /etc/services for the service name
        // wbem-exp-https and bind to that port. If the service is  not defined
        // then log a warning message and do not start the cimserver.
        //
        Uint32 port = 0;

        portNumberExportHttps = System::lookupPort(WBEM_EXPORT_HTTPS_SERVICE_NAME, port);

        if (portNumberExportHttps == 0)
        {
            Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
                "src.Server.cimserver.EXPORT_HTTPS_PORT_NOT_DEFINED",
                "Port not defined for the service wbem-exp-https. CIMServer will not be started.");

            MessageLoaderParms parms("src.Server.cimserver.EXPORT_HTTPS_PORT_NOT_DEFINED",
                "Port not defined for the service wbem-exp-https. CIMServer will not be started.");

            cerr << MessageLoader::getMessage(parms) << endl;

            return(1);
        }
    }
#if defined(PEGASUS_DEBUG)
    // Put out startup up message.
    cout << _cimServerProcess->getProductName() << " " << _cimServerProcess->getVersion() << endl;
    //l10n
    //cout << "Built " << __DATE__ << " " << __TIME__ << endl;
    //cout <<"Starting..."
    MessageLoaderParms parms("src.Server.cimserver.STARTUP_MESSAGE",
                             "Built $0 $1\nStarting...",
                             __DATE__,
                             __TIME__);
#endif

//l10n
// reset message loading to NON-process locale
MessageLoader::_useProcessLocale = false;
//l10n

    // Get the parent's PID before forking
    _cimServerProcess->set_parent_pid(System::getPID());

    // do we need to run as a daemon ?
    if (daemonOption)
    {
        if(-1 == _cimServerProcess->cimserver_fork())
#ifndef PEGASUS_OS_OS400
    {
        return(-1);
    }
#else
    {
            return(-1);
    }
    else
    {
        return(0);
    }
#endif

    }

// l10n
    // Now we are after the fork...
    // Create a dummy Thread object that can be used to store the
    // AcceptLanguages object for CIM requests that are serviced
    // by this thread (initial thread of server).  Need to do this
    // because this thread is not in a ThreadPool, but is used
    // to service CIM requests.
    // The run function for the dummy Thread should never be called,
    Thread *dummyInitialThread = new Thread(dummyThreadFunc, NULL, false);
    Thread::setCurrent(dummyInitialThread);
    AcceptLanguages default_al;
    try{
         default_al = AcceptLanguages::getDefaultAcceptLanguages();
         Thread::setLanguages(new AcceptLanguages(default_al));
    }catch(InvalidAcceptLanguageHeader& e){
          Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                  "src.Server.cimserver.FAILED_TO_SET_PROCESS_LOCALE",
                  "Could not convert the system process locale into a valid AcceptLanguage format.");
          Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                             e.getMessage());
    }

#ifdef PEGASUS_OS_OS400
    // Special server initialization code for OS/400.
    if (cimserver_initialize() != 0)
    {
    // do some logging here!
    //l10n
    //Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
            //"CIM Server failed to initialize");
    Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                  "src.Server.cimserver.SERVER_FAILED_TO_INITIALIZE",
                  "CIM Server failed to initialize");
    return(-1);
    }
#endif

#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) \
|| defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_OS_AIX) \
|| defined(PEGASUS_PLATFORM_SOLARIS_SPARC_CC) || defined (PEGASUS_OS_VMS)
    umask(S_IWGRP|S_IWOTH);

    //
    // check if CIMServer is already running
    // if CIMServer is already running, print message and
    // notify parent process (if there is a parent process) to terminate
    //
    if(_cimServerProcess->isCIMServerRunning())
    {
    //l10n
        //cout << "Unable to start CIMServer." << endl;
        //cout << "CIMServer is already running." << endl;
        MessageLoaderParms parms("src.Server.cimserver.UNABLE_TO_START_SERVER_ALREADY_RUNNING",
                     "Unable to start CIMServer.\nCIMServer is already running.");
    PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);

    //
        // notify parent process (if there is a parent process) to terminate
        //
        if (daemonOption)
                _cimServerProcess->notify_parent(1);

        return(1);
    }

#endif

    // try loop to bind the address, and run the server
    try
    {

    _monitor  = new Monitor();
    //PEP#222
    //CIMServer server(&monitor);
    //CimserverHolder cimserverHolder( &server );
    _cimServer = new CIMServer(_monitor);

        if (enableHttpConnection)
        {
            _cimServer->addAcceptor(false, portNumberHttp, false, false);
            //l10n
            //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                        //"Listening on HTTP port $0.", portNumberHttp);

            Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                            "src.Server.cimserver.LISTENING_ON_HTTP_PORT",
                            "Listening on HTTP port $0.", portNumberHttp);
        }
        if (enableHttpsConnection)
        {
            _cimServer->addAcceptor(false, portNumberHttps, true, false);
            //l10n
            //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                        //"Listening on HTTPS port $0.", portNumberHttps);
            Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                            "src.Server.cimserver.LISTENING_ON_HTTPS_PORT",
                            "Listening on HTTPS port $0.", portNumberHttps);
        }
        if (enableSSLExportClientVerification)
        {
            _cimServer->addAcceptor(false, portNumberExportHttps, true, true);

            Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                "src.Server.cimserver.LISTENING_ON_EXPORT_HTTPS_PORT",
                "Listening on Export HTTPS port $0.", portNumberExportHttps);
        }

#ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
        _cimServer->addAcceptor(true, 0, false, false);
        //l10n
        //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                    //"Listening on local connection socket.");
        Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
              "src.Server.cimserver.LISTENING_ON_LOCAL",
              "Listening on local connection socket.");
#endif

#if defined(PEGASUS_DEBUG)
        if (enableHttpConnection)
        {
            //l10n
            //cout << "Listening on HTTP port " << portNumberHttp << endl;
      MessageLoaderParms parms("src.Server.cimserver.LISTENING_ON_HTTP_PORT",
                   "Listening on HTTP port $0.", portNumberHttp);
            cout << MessageLoader::getMessage(parms) << endl;
        }
        if (enableHttpsConnection)
        {
            //l10n
            //cout << "Listening on HTTPS port " << portNumberHttps << endl;
            MessageLoaderParms parms("src.Server.cimserver.LISTENING_ON_HTTPS_PORT",
                     "Listening on HTTPS port $0.", portNumberHttps);
            cout << MessageLoader::getMessage(parms) << endl;
        }
        if (enableSSLExportClientVerification)
        {
            MessageLoaderParms parms("src.Server.cimserver.LISTENING_ON_EXPORT_HTTPS_PORT",
                "Listening on Export HTTPS port $0.", portNumberExportHttps);

            cout << MessageLoader::getMessage(parms) << endl;
        }

# ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
        //l10n
        //cout << "Listening on local connection socket" << endl;
        MessageLoaderParms parms("src.Server.cimserver.LISTENING_ON_LOCAL",
                 "Listening on local connection socket.");
        cout << MessageLoader::getMessage(parms) << endl;
# endif
#endif

        // bind throws an exception if the bind fails
        try {
           _cimServer->bind();
	} catch (const BindFailedException &e)
	{
#ifdef PEGASUS_DEBUG
        MessageLoaderParms parms("src.Server.cimserver.BIND_FAILED",
                 "Could not bind: $0.", e.getMessage());
        cout << MessageLoader::getMessage(parms) << endl;
#endif
        Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
            "src.Server.cimserver.BIND.FAILED",
            "Could not bind:  $0", e.getMessage());

	   deleteCIMServer();
	   return 1;
	}
    // notify parent process (if there is a parent process) to terminate
        // so user knows that there is cimserver ready to serve CIM requests.
    if (daemonOption)
        _cimServerProcess->notify_parent(0);

    time_t last = 0;

#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_OS_LINUX) || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) \
    || defined(PEGASUS_OS_AIX) || defined(PEGASUS_PLATFORM_SOLARIS_SPARC_CC) \
    || defined(PEGASUS_OS_VMS)
        //
        // create a file to indicate that the cimserver has started and
        // save the process id of the cimserver process in the file
        //
        // remove the old file if it exists
        System::removeFile(_cimServerProcess->getPIDFileName());

        // open the file
        FILE *pid_file = fopen(_cimServerProcess->getPIDFileName(), "w");

        if (pid_file)
        {
            // save the pid in the file
            fprintf(pid_file, "%ld\n", _cimServerProcess->get_server_pid());
            fclose(pid_file);
        }
#endif

#if defined(PEGASUS_DEBUG)
    cout << "Started. " << endl;
#endif

        // Put server started message to the logger
        Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,
            Logger::INFORMATION,
            "src.Server.cimserver.STARTED_VERSION",
            "Started $0 version $1.",
            _cimServerProcess->getProductName(), _cimServerProcess->getVersion());

        //
        // Loop to call CIMServer's runForever() method until CIMServer
        // has been shutdown
        //
    while( !_cimServer->terminated() )
    {

      _cimServer->runForever();

    }

        //
        // normal termination
        //

        // Put server shutdown message to the logger
        Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,
            Logger::INFORMATION, "src.Server.cimserver.STOPPED",
            "$0 stopped.", _cimServerProcess->getProductName());

#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) \
|| defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_OS_AIX) \
|| defined(PEGASUS_PLATFORM_SOLARIS_SPARC_CC) || defined(PEGASUS_OS_VMS)
        //
        // close the file created at startup time to indicate that the
        // cimserver has terminated normally.
        //
        FileSystem::removeFile(_cimServerProcess->getPIDFileName());
#endif
    }
    catch(Exception& e)
    {

    //l10n
    //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
            //"Error: $0", e.getMessage());
    Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
            "src.Server.cimserver.ERROR",
            "Error: $0", e.getMessage());

#ifndef PEGASUS_OS_OS400
    //l10n
    //PEGASUS_STD(cerr) << "Error: " << e.getMessage() << PEGASUS_STD(endl);
    MessageLoaderParms parms("src.Server.cimserver.ERROR",
                             "Error: $0", e.getMessage());
    PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);

#endif

    //
        // notify parent process (if there is a parent process) to terminate
        //
        if (daemonOption)
                _cimServerProcess->notify_parent(1);

        deleteCIMServer();
        return 1;
    }

    deleteCIMServer();
    return 0;
}


text:
try:
    from ._models_py3 import AccountCredentialDetails
    from ._models_py3 import AddressValidationOutput
    from ._models_py3 import AddressValidationProperties
    from ._models_py3 import ApplianceNetworkConfiguration
    from ._models_py3 import ArmBaseObject
    from ._models_py3 import AvailableSkuRequest
    from ._models_py3 import AvailableSkusResult
    from ._models_py3 import CancellationReason
    from ._models_py3 import CloudError
    from ._models_py3 import ContactDetails
    from ._models_py3 import CopyLogDetails
    from ._models_py3 import CopyProgress
    from ._models_py3 import CreateJobValidations
    from ._models_py3 import CreateOrderLimitForSubscriptionValidationRequest
    from ._models_py3 import CreateOrderLimitForSubscriptionValidationResponseProperties
    from ._models_py3 import DataBoxAccountCopyLogDetails
    from ._models_py3 import DataBoxDiskCopyLogDetails
    from ._models_py3 import DataBoxDiskCopyProgress
    from ._models_py3 import DataBoxDiskJobDetails
    from ._models_py3 import DataBoxDiskJobSecrets
    from ._models_py3 import DataBoxHeavyAccountCopyLogDetails
    from ._models_py3 import DataBoxHeavyJobDetails
    from ._models_py3 import DataBoxHeavyJobSecrets
    from ._models_py3 import DataBoxHeavySecret
    from ._models_py3 import DataBoxJobDetails
    from ._models_py3 import DataBoxScheduleAvailabilityRequest
    from ._models_py3 import DataBoxSecret
    from ._models_py3 import DataDestinationDetailsValidationRequest
    from ._models_py3 import DataDestinationDetailsValidationResponseProperties
    from ._models_py3 import DataboxJobSecrets
    from ._models_py3 import DcAccessSecurityCode
    from ._models_py3 import DestinationAccountDetails
    from ._models_py3 import DestinationManagedDiskDetails
    from ._models_py3 import DestinationStorageAccountDetails
    from ._models_py3 import DestinationToServiceLocationMap
    from ._models_py3 import DiskScheduleAvailabilityRequest
    from ._models_py3 import DiskSecret
    from ._models_py3 import Error
    from ._models_py3 import HeavyScheduleAvailabilityRequest
    from ._models_py3 import JobDeliveryInfo
    from ._models_py3 import JobDetails
    from ._models_py3 import JobErrorDetails
    from ._models_py3 import JobResource
    from ._models_py3 import JobResourceList
    from ._models_py3 import JobResourceUpdateParameter
    from ._models_py3 import JobSecrets
    from ._models_py3 import JobStages
    from ._models_py3 import NotificationPreference
    from ._models_py3 import Operation
    from ._models_py3 import OperationDisplay
    from ._models_py3 import OperationList
    from ._models_py3 import PackageShippingDetails
    from ._models_py3 import Preferences
    from ._models_py3 import PreferencesValidationRequest
    from ._models_py3 import PreferencesValidationResponseProperties
    from ._models_py3 import RegionConfigurationRequest
    from ._models_py3 import RegionConfigurationResponse
    from ._models_py3 import Resource
    from ._models_py3 import ScheduleAvailabilityRequest
    from ._models_py3 import ScheduleAvailabilityResponse
    from ._models_py3 import ShareCredentialDetails
    from ._models_py3 import ShipmentPickUpRequest
    from ._models_py3 import ShipmentPickUpResponse
    from ._models_py3 import ShippingAddress
    from ._models_py3 import Sku
    from ._models_py3 import SkuAvailabilityValidationRequest
    from ._models_py3 import SkuAvailabilityValidationResponseProperties
    from ._models_py3 import SkuCapacity
    from ._models_py3 import SkuCost
    from ._models_py3 import SkuInformation
    from ._models_py3 import SubscriptionIsAllowedToCreateJobValidationRequest
    from ._models_py3 import SubscriptionIsAllowedToCreateJobValidationResponseProperties
    from ._models_py3 import TransportAvailabilityDetails
    from ._models_py3 import TransportAvailabilityRequest
    from ._models_py3 import TransportAvailabilityResponse
    from ._models_py3 import TransportPreferences
    from ._models_py3 import UnencryptedCredentials
    from ._models_py3 import UnencryptedCredentialsList
    from ._models_py3 import UpdateJobDetails
    from ._models_py3 import ValidateAddress
    from ._models_py3 import ValidationInputRequest
    from ._models_py3 import ValidationInputResponse
    from ._models_py3 import ValidationRequest
    from ._models_py3 import ValidationResponse
except (SyntaxError, ImportError):
    from ._models import AccountCredentialDetails  # type: ignore
    from ._models import AddressValidationOutput  # type: ignore
    from ._models import AddressValidationProperties  # type: ignore
    from ._models import ApplianceNetworkConfiguration  # type: ignore
    from ._models import ArmBaseObject  # type: ignore
    from ._models import AvailableSkuRequest  # type: ignore
    from ._models import AvailableSkusResult  # type: ignore
    from ._models import CancellationReason  # type: ignore
    from ._models import CloudError  # type: ignore
    from ._models import ContactDetails  # type: ignore
    from ._models import CopyLogDetails  # type: ignore
    from ._models import CopyProgress  # type: ignore
    from ._models import CreateJobValidations  # type: ignore
    from ._models import CreateOrderLimitForSubscriptionValidationRequest  # type: ignore
    from ._models import CreateOrderLimitForSubscriptionValidationResponseProperties  # type: ignore
    from ._models import DataBoxAccountCopyLogDetails  # type: ignore
    from ._models import DataBoxDiskCopyLogDetails  # type: ignore
    from ._models import DataBoxDiskCopyProgress  # type: ignore
    from ._models import DataBoxDiskJobDetails  # type: ignore
    from ._models import DataBoxDiskJobSecrets  # type: ignore
    from ._models import DataBoxHeavyAccountCopyLogDetails  # type: ignore
    from ._models import DataBoxHeavyJobDetails  # type: ignore
    from ._models import DataBoxHeavyJobSecrets  # type: ignore
    from ._models import DataBoxHeavySecret  # type: ignore
    from ._models import DataBoxJobDetails  # type: ignore
    from ._models import DataBoxScheduleAvailabilityRequest  # type: ignore
    from ._models import DataBoxSecret  # type: ignore
    from ._models import DataDestinationDetailsValidationRequest  # type: ignore
    from ._models import DataDestinationDetailsValidationResponseProperties  # type: ignore
    from ._models import DataboxJobSecrets  # type: ignore
    from ._models import DcAccessSecurityCode  # type: ignore
    from ._models import DestinationAccountDetails  # type: ignore
    from ._models import DestinationManagedDiskDetails  # type: ignore
    from ._models import DestinationStorageAccountDetails  # type: ignore
    from ._models import DestinationToServiceLocationMap  # type: ignore
    from ._models import DiskScheduleAvailabilityRequest  # type: ignore
    from ._models import DiskSecret  # type: ignore
    from ._models import Error  # type: ignore
    from ._models import HeavyScheduleAvailabilityRequest  # type: ignore
    from ._models import JobDeliveryInfo  # type: ignore
    from ._models import JobDetails  # type: ignore
    from ._models import JobErrorDetails  # type: ignore
    from ._models import JobResource  # type: ignore
    from ._models import JobResourceList  # type: ignore
    from ._models import JobResourceUpdateParameter  # type: ignore
    from ._models import JobSecrets  # type: ignore
    from ._models import JobStages  # type: ignore
    from ._models import NotificationPreference  # type: ignore
    from ._models import Operation  # type: ignore
    from ._models import OperationDisplay  # type: ignore
    from ._models import OperationList  # type: ignore
    from ._models import PackageShippingDetails  # type: ignore
    from ._models import Preferences  # type: ignore
    from ._models import PreferencesValidationRequest  # type: ignore
    from ._models import PreferencesValidationResponseProperties  # type: ignore
    from ._models import RegionConfigurationRequest  # type: ignore
    from ._models import RegionConfigurationResponse  # type: ignore
    from ._models import Resource  # type: ignore
    from ._models import ScheduleAvailabilityRequest  # type: ignore
    from ._models import ScheduleAvailabilityResponse  # type: ignore
    from ._models import ShareCredentialDetails  # type: ignore
    from ._models import ShipmentPickUpRequest  # type: ignore
    from ._models import ShipmentPickUpResponse  # type: ignore
    from ._models import ShippingAddress  # type: ignore
    from ._models import Sku  # type: ignore
    from ._models import SkuAvailabilityValidationRequest  # type: ignore
    from ._models import SkuAvailabilityValidationResponseProperties  # type: ignore
    from ._models import SkuCapacity  # type: ignore
    from ._models import SkuCost  # type: ignore
    from ._models import SkuInformation  # type: ignore
    from ._models import SubscriptionIsAllowedToCreateJobValidationRequest  # type: ignore
    from ._models import SubscriptionIsAllowedToCreateJobValidationResponseProperties  # type: ignore
    from ._models import TransportAvailabilityDetails  # type: ignore
    from ._models import TransportAvailabilityRequest  # type: ignore
    from ._models import TransportAvailabilityResponse  # type: ignore
    from ._models import TransportPreferences  # type: ignore
    from ._models import UnencryptedCredentials  # type: ignore
    from ._models import UnencryptedCredentialsList  # type: ignore
    from ._models import UpdateJobDetails  # type: ignore
    from ._models import ValidateAddress  # type: ignore
    from ._models import ValidationInputRequest  # type: ignore
    from ._models import ValidationInputResponse  # type: ignore
    from ._models import ValidationRequest  # type: ignore
    from ._models import ValidationResponse  # type: ignore

from ._data_box_management_client_enums import (
    AccessProtocol,
    AddressType,
    AddressValidationStatus,
    ClassDiscriminator,
    CopyStatus,
    DataDestinationType,
    JobDeliveryType,
    NotificationStageName,
    OverallValidationStatus,
    ShareDestinationFormatType,
    SkuDisabledReason,
    SkuName,
    StageName,
    StageStatus,
    TransportShipmentTypes,
    ValidationInputDiscriminator,
    ValidationStatus,
)

__all__ = [
    'AccountCredentialDetails',
    'AddressValidationOutput',
    'AddressValidationProperties',
    'ApplianceNetworkConfiguration',
    'ArmBaseObject',
    'AvailableSkuRequest',
    'AvailableSkusResult',
    'CancellationReason',
    'CloudError',
    'ContactDetails',
    'CopyLogDetails',
    'CopyProgress',
    'CreateJobValidations',
    'CreateOrderLimitForSubscriptionValidationRequest',
    'CreateOrderLimitForSubscriptionValidationResponseProperties',
    'DataBoxAccountCopyLogDetails',
    'DataBoxDiskCopyLogDetails',
    'DataBoxDiskCopyProgress',
    'DataBoxDiskJobDetails',
    'DataBoxDiskJobSecrets',
    'DataBoxHeavyAccountCopyLogDetails',
    'DataBoxHeavyJobDetails',
    'DataBoxHeavyJobSecrets',
    'DataBoxHeavySecret',
    'DataBoxJobDetails',
    'DataBoxScheduleAvailabilityRequest',
    'DataBoxSecret',
    'DataDestinationDetailsValidationRequest',
    'DataDestinationDetailsValidationResponseProperties',
    'DataboxJobSecrets',
    'DcAccessSecurityCode',
    'DestinationAccountDetails',
    'DestinationManagedDiskDetails',
    'DestinationStorageAccountDetails',
    'DestinationToServiceLocationMap',
    'DiskScheduleAvailabilityRequest',
    'DiskSecret',
    'Error',
    'HeavyScheduleAvailabilityRequest',
    'JobDeliveryInfo',
    'JobDetails',
    'JobErrorDetails',
    'JobResource',
    'JobResourceList',
    'JobResourceUpdateParameter',
    'JobSecrets',
    'JobStages',
    'NotificationPreference',
    'Operation',
    'OperationDisplay',
    'OperationList',
    'PackageShippingDetails',
    'Preferences',
    'PreferencesValidationRequest',
    'PreferencesValidationResponseProperties',
    'RegionConfigurationRequest',
    'RegionConfigurationResponse',
    'Resource',
    'ScheduleAvailabilityRequest',
    'ScheduleAvailabilityResponse',
    'ShareCredentialDetails',
    'ShipmentPickUpRequest',
    'ShipmentPickUpResponse',
    'ShippingAddress',
    'Sku',
    'SkuAvailabilityValidationRequest',
    'SkuAvailabilityValidationResponseProperties',
    'SkuCapacity',
    'SkuCost',
    'SkuInformation',
    'SubscriptionIsAllowedToCreateJobValidationRequest',
    'SubscriptionIsAllowedToCreateJobValidationResponseProperties',
    'TransportAvailabilityDetails',
    'TransportAvailabilityRequest',
    'TransportAvailabilityResponse',
    'TransportPreferences',
    'UnencryptedCredentials',
    'UnencryptedCredentialsList',
    'UpdateJobDetails',
    'ValidateAddress',
    'ValidationInputRequest',
    'ValidationInputResponse',
    'ValidationRequest',
    'ValidationResponse',
    'AccessProtocol',
    'AddressType',
    'AddressValidationStatus',
    'ClassDiscriminator',
    'CopyStatus',
    'DataDestinationType',
    'JobDeliveryType',
    'NotificationStageName',
    'OverallValidationStatus',
    'ShareDestinationFormatType',
    'SkuDisabledReason',
    'SkuName',
    'StageName',
    'StageStatus',
    'TransportShipmentTypes',
    'ValidationInputDiscriminator',
    'ValidationStatus',
]

redpajama_set_name: RedPajamaGithub


text:
global.threevot = {}

var Path = require("path")
var Fs = require("fs")
var gulp = require('gulp');
var gutil = require('gulp-util');
var chalk = require('chalk');

var localPath = Path.join( process.cwd(), "gulpfile.js" )

var localPath = process.cwd();
var originalTaks = gulp.tasks;

var minimist = require("minimist")
var args = minimist( process.argv );

var env = "";
if( args.env ) env = "-" + args.env

try{
	require('dotenv').config({path: './.env' + env});
}catch(e){ console.warning('Could not load .env file - vars should be loaded externally') }

var p = require( Path.join( process.cwd() , "package.json" ) );

var platform = args.platform || process.env.platform;

if( platform ) process.env.NAME = platform;
if( !process.env.NAME ) process.env.NAME = p.name;

if( !process.env.DIST_FOLDER ) process.env.DIST_FOLDER = "./dist";
if( !process.env.ZIP_NAME ) process.env.ZIP_NAME = process.env.NAME;
if( !process.env.ZIP_FOLDER ) process.env.ZIP_FOLDER = process.cwd();

console.log( chalk.magenta('Welcome to CLAY by 3VOT.com') );

require("./tasks/app")
require("./tasks/dist")


text:
<component name="CopyrightManager">
  <settings default="">
    <module2copyright>
      <element module="All" copyright="Graviron57" />
    </module2copyright>
  </settings>
</component>


text:
package com.strategicgains.syntaxe.validator.impl;

import java.lang.reflect.Field;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import com.strategicgains.syntaxe.annotation.CollectionValidation;
import com.strategicgains.syntaxe.util.Validations;
import com.strategicgains.syntaxe.validator.AnnotatedFieldValidator;

public class CollectionValidator
extends AnnotatedFieldValidator<CollectionValidation>
{
	public CollectionValidator(Field field, CollectionValidation annotation)
	{
		super(field, annotation);
	}

	@SuppressWarnings("unchecked")
	@Override
	public void perform(Object instance, List<String> errors, String prefix)
	{
		String name = determineName(prefix);
		Object value = getValue(instance);

		if (getAnnotation().isNullable() && value == null)
		{
			return;
		}
		else if (!getAnnotation().isNullable())
		{
	    	if (value == null)
	    	{
	    		errors.add(name + " is required");
	    		return;
	    	}
		}

		if(isCollection())
		{
			validate(name, value, errors);
		}
		if(isMap())
		{
			validate(name, ((Map<?, Object>) value).values(), errors);
		}

		else if (isArray())
		{
			int length = (instance == null ? 0 : ((Object[]) getValue(instance)).length);
			Validations.greaterThanOrEqual(name, length, getAnnotation().minSize(), errors);
			Validations.lessThanOrEqual(name, length, getAnnotation().maxSize(), errors);
		}
    }

    @Override
	protected void validate(String name, Object value, List<String> errors)
	{
		@SuppressWarnings("unchecked")
		int size = (value == null ? 0 : ((Collection<Object>) value).size());
		Validations.greaterThanOrEqual(name, size, getAnnotation().minSize(), errors);
		Validations.lessThanOrEqual(name, size, getAnnotation().maxSize(), errors);
	}

    private String determineName(String prefix)
    {
    	return (getAnnotation().name().isEmpty() ? trimPrefix(prefix) + getFieldName() : getAnnotation().name());
    }
}


text:
/*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
*/
var DelegatedSourceDependency = require("./dependencies/DelegatedSourceDependency");
var DelegatedModuleFactoryPlugin = require("./DelegatedModuleFactoryPlugin");
var ExternalModuleFactoryPlugin = require("./ExternalModuleFactoryPlugin");

function DllReferencePlugin(options) {
	this.options = options;
}
module.exports = DllReferencePlugin;
DllReferencePlugin.prototype.apply = function(compiler) {
	compiler.plugin("compilation", function(compilation, params) {
		var normalModuleFactory = params.normalModuleFactory;

		compilation.dependencyFactories.set(DelegatedSourceDependency, normalModuleFactory);
	});
	compiler.plugin("before-compile", function(params, callback) {
		var manifest = this.options.manifest;
		if(typeof manifest === "string") {
			params.compilationDependencies.push(manifest);
			compiler.inputFileSystem.readFile(manifest, function(err, result) {
				if(err) return callback(err);
				params["dll reference " + manifest] = JSON.parse(result.toString("utf-8"));
				return callback();
			});
		} else {
			return callback();
		}
	}.bind(this));
	compiler.plugin("compile", function(params) {
		var manifest = this.options.manifest;
		if(typeof manifest === "string") {
			manifest = params["dll reference " + manifest];
		}
		var name = this.options.name || manifest.name;
		var sourceType = this.options.sourceType || "var";
		var externals = {};
		var source = "dll-reference " + name;
		externals[source] = name;
		params.normalModuleFactory.apply(new ExternalModuleFactoryPlugin(sourceType, externals));
		params.normalModuleFactory.apply(new DelegatedModuleFactoryPlugin({
			source: source,
			type: this.options.type,
			scope: this.options.scope,
			context: this.options.context || compiler.options.context,
			content: this.options.content || manifest.content,
			extensions: this.options.extensions
		}));
	}.bind(this));
};


text:
require 'kontena/plugin_manager'
require 'json'

describe Kontena::PluginManager::RubygemsClient do
  let(:subject) { described_class.new }
  let(:client) { double }

  before(:each) do
    allow(subject).to receive(:client).and_return(client)
  end

  context '#search' do
    it 'searches rubygems and returns a hash' do
      expect(subject).to receive(:client).and_return(client)
      expect(client).to receive(:request) do |req|
        expect(req.path).to eq '/api/v1/search.json?query=foofoo'
        expect(req['Accept']).to eq 'application/json'
      end.and_return(double(body: JSON.dump(foo: 'bar'), code: "200"))
      expect(subject.search('foofoo')['foo']).to eq 'bar'
    end
  end

  context '#versions' do
    it 'fetches version list from rubygems and returns an array of Gem::Versions' do
      expect(subject).to receive(:client).and_return(client)
      expect(client).to receive(:request) do |req|
        expect(req.path).to eq '/api/v1/versions/foofoo.json'
        expect(req['Accept']).to eq 'application/json'
      end.and_return(double(body: JSON.dump([{'number' => '0.1.0'}, {'number' => '0.2.0'}]), code: "200"))
      versions = subject.versions('foofoo')
      expect(versions.first).to be_kind_of Gem::Version
      expect(versions.first.to_s).to eq '0.2.0'
      expect(versions.last.to_s).to eq '0.1.0'
    end
  end
end


text:
package org.killbill.billing.invoice.model;

import java.math.BigDecimal;
import java.util.UUID;

import javax.annotation.Nullable;

import org.joda.time.DateTime;
import org.joda.time.LocalDate;
import org.killbill.billing.catalog.api.Currency;
import org.killbill.billing.entity.EntityBase;
import org.killbill.billing.invoice.api.InvoiceItem;
import org.killbill.billing.invoice.api.InvoiceItemType;
import org.killbill.billing.util.currency.KillBillMoney;

public abstract class InvoiceItemBase extends EntityBase implements InvoiceItem {

    /* Common to all items */
    protected final UUID invoiceId;
    protected final UUID accountId;
    protected final UUID childAccountId;
    protected final LocalDate startDate;
    protected final LocalDate endDate;
    protected final BigDecimal amount;
    protected final Currency currency;
    protected final String description;

    /* Fixed and recurring specific */
    protected final UUID subscriptionId;
    protected final UUID bundleId;
    protected final String planName;
    protected final String phaseName;

    /* Recurring specific */
    protected final BigDecimal rate;

    /* RepairAdjInvoiceItem */
    protected final UUID linkedItemId;

    /* Usage specific */
    protected final String usageName;

    @Override
    public String toString() {
        // Note: we don't use all fields here, as the output would be overwhelming
        // (we output all invoice items as they are generated).
        final StringBuilder sb = new StringBuilder();
        sb.append(getInvoiceItemType());
        sb.append("{startDate=").append(startDate);
        sb.append(", endDate=").append(endDate);
        sb.append(", amount=").append(amount);
        sb.append(", rate=").append(rate);
        sb.append(", subscriptionId=").append(subscriptionId);
        sb.append(", linkedItemId=").append(linkedItemId);
        sb.append('}');
        return sb.toString();
    }

    /*
    * CTORs with ID; called from DAO when rehydrating
    */
    // No rate and no reversing item
    public InvoiceItemBase(final UUID id, @Nullable final DateTime createdDate, final UUID invoiceId, final UUID accountId, @Nullable final UUID bundleId,
                           @Nullable final UUID subscriptionId, @Nullable final String description, @Nullable final String planName, @Nullable final String phaseName, @Nullable final String usageName,
                           final LocalDate startDate, final LocalDate endDate, final BigDecimal amount, final Currency currency) {
        this(id, createdDate, invoiceId, accountId, null, bundleId, subscriptionId, description, planName, phaseName, usageName, startDate, endDate, amount, null, currency, null);
    }

    // With rate but no reversing item
    public InvoiceItemBase(final UUID id, @Nullable final DateTime createdDate, final UUID invoiceId, final UUID accountId, @Nullable final UUID bundleId,
                           @Nullable final UUID subscriptionId, @Nullable final String description, @Nullable final String planName, @Nullable final String phaseName, @Nullable final String usageName,
                           final LocalDate startDate, final LocalDate endDate, final BigDecimal amount, final BigDecimal rate, final Currency currency) {
        this(id, createdDate, invoiceId, accountId, null, bundleId, subscriptionId, description, planName, phaseName, usageName, startDate, endDate, amount, rate, currency, null);
    }

    // With  reversing item, no rate
    public InvoiceItemBase(final UUID id, @Nullable final DateTime createdDate, final UUID invoiceId, final UUID accountId, @Nullable final UUID bundleId,
                           @Nullable final UUID subscriptionId, @Nullable final String description, @Nullable final String planName, @Nullable final String phaseName, @Nullable final String usageName,
                           final LocalDate startDate, final LocalDate endDate, final BigDecimal amount, final Currency currency, final UUID reversedItemId) {
        this(id, createdDate, invoiceId, accountId, null, bundleId, subscriptionId, description, planName, phaseName, usageName, startDate, endDate, amount, null, currency, reversedItemId);
    }

    // For parent invoices
    public InvoiceItemBase(final UUID id, @Nullable final DateTime createdDate, final UUID invoiceId, final UUID accountId, final UUID childAccountId,
                             final BigDecimal amount, final Currency currency, final String description) {
        this(id, createdDate, invoiceId, accountId, childAccountId, null, null, description, null, null, null, null, null, amount, null, currency, null);
    }

    private InvoiceItemBase(final UUID id, @Nullable final DateTime createdDate, final UUID invoiceId, final UUID accountId, @Nullable final UUID childAccountId, @Nullable final UUID bundleId,
                            @Nullable final UUID subscriptionId, @Nullable final String description, @Nullable final String planName, @Nullable final String phaseName, @Nullable final String usageName,
                            @Nullable final LocalDate startDate, final LocalDate endDate, final BigDecimal amount, final BigDecimal rate, final Currency currency,
                            final UUID reversedItemId) {
        super(id, createdDate, createdDate);
        this.invoiceId = invoiceId;
        this.accountId = accountId;
        this.childAccountId = childAccountId;
        this.subscriptionId = subscriptionId;
        this.bundleId = bundleId;
        this.description = description;
        this.planName = planName;
        this.phaseName = phaseName;
        this.usageName = usageName;
        this.startDate = startDate;
        this.endDate = endDate;
        this.amount = amount == null || currency == null ? amount : KillBillMoney.of(amount, currency);
        this.currency = currency;
        this.rate = rate;
        this.linkedItemId = reversedItemId;
    }

    @Override
    public UUID getInvoiceId() {
        return invoiceId;
    }

    @Override
    public UUID getBundleId() {
        return bundleId;
    }

    @Override
    public UUID getAccountId() {
        return accountId;
    }

    @Override
    public UUID getSubscriptionId() {
        return subscriptionId;
    }

    @Override
    public String getPlanName() {
        return planName;
    }

    @Override
    public String getPhaseName() {
        return phaseName;
    }

    @Override
    public BigDecimal getAmount() {
        return amount;
    }

    @Override
    public LocalDate getStartDate() {
        return startDate;
    }

    @Override
    public LocalDate getEndDate() {
        return endDate;
    }

    @Override
    public Currency getCurrency() {
        return currency;
    }

    @Override
    public BigDecimal getRate() {
        return rate;
    }

    @Override
    public UUID getLinkedItemId() {
        return linkedItemId;
    }

    @Override
    public String getUsageName() {
        return usageName;
    }

    @Override
    public UUID getChildAccountId() {
        return childAccountId;
    }

    @Override
    public boolean equals(final Object o) {

        if (!matches(o)) {
            return false;
        }
        final InvoiceItemBase that = (InvoiceItemBase) o;
        if (!super.equals(that)) {
            return false;
        }
        if (invoiceId != null ? !invoiceId.equals(that.invoiceId) : that.invoiceId != null) {
            return false;
        }
        if (linkedItemId != null ? !linkedItemId.equals(that.linkedItemId) : that.linkedItemId != null) {
            return false;
        }
        if (description != null ? !description.equals(that.description) : that.description != null) {
            return false;
        }
        return true;
    }

    @Override
    public boolean matches(final Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof InvoiceItemBase)) {
            return false;
        }

        final InvoiceItemBase that = (InvoiceItemBase) o;

        if (accountId != null ? !accountId.equals(that.accountId) : that.accountId != null) {
            return false;
        }
        if (childAccountId != null ? !childAccountId.equals(that.childAccountId) : that.childAccountId != null) {
            return false;
        }
        if (bundleId != null ? !bundleId.equals(that.bundleId) : that.bundleId != null) {
            return false;
        }
        if (subscriptionId != null ? !subscriptionId.equals(that.subscriptionId) : that.subscriptionId != null) {
            return false;
        }
        if (safeCompareTo(startDate, that.startDate) != 0) {
            return false;
        }
        if (safeCompareTo(endDate, that.endDate) != 0) {
            return false;
        }
        if (safeCompareTo(amount, that.amount) != 0) {
            return false;
        }
        if (safeCompareTo(rate, that.rate) != 0) {
            return false;
        }
        if (currency != that.currency) {
            return false;
        }
        if (phaseName != null ? !phaseName.equals(that.phaseName) : that.phaseName != null) {
            return false;
        }
        if (planName != null ? !planName.equals(that.planName) : that.planName != null) {
            return false;
        }
        return true;
    }

    @Override
    public int hashCode() {
        int result = super.hashCode();
        result = 31 * result + (invoiceId != null ? invoiceId.hashCode() : 0);
        result = 31 * result + (accountId != null ? accountId.hashCode() : 0);
        result = 31 * result + (childAccountId != null ? childAccountId.hashCode() : 0);
        result = 31 * result + (startDate != null ? startDate.hashCode() : 0);
        result = 31 * result + (endDate != null ? endDate.hashCode() : 0);
        result = 31 * result + (amount != null ? amount.hashCode() : 0);
        result = 31 * result + (currency != null ? currency.hashCode() : 0);
        result = 31 * result + (subscriptionId != null ? subscriptionId.hashCode() : 0);
        result = 31 * result + (bundleId != null ? bundleId.hashCode() : 0);
        result = 31 * result + (description != null ? description.hashCode() : 0);
        result = 31 * result + (planName != null ? planName.hashCode() : 0);
        result = 31 * result + (phaseName != null ? phaseName.hashCode() : 0);
        result = 31 * result + (rate != null ? rate.hashCode() : 0);
        result = 31 * result + (linkedItemId != null ? linkedItemId.hashCode() : 0);
        return result;
    }

    @Override
    public abstract InvoiceItemType getInvoiceItemType();

    @Override
    public abstract String getDescription();
}


text:
jquery-methodOverride
=================

More HTTP methods for `jQuery.ajax`, emulated for cross-browser support.
Enhance forms with method overrides.

Great for integrating with a RESTful API (see [Framework support](#framework-support)).

Uses conventions like the `X-HTTP-Method-Override` header and the hidden `_method` parameter to proxy the lesser-used methods through the fully-supported `GET` and `POST`.

## Proxied methods

The "useful" methods from [RFC 2616] are supported, proxied as follows:

* `PUT`: `POST`
* `PATCH`: `POST`
* `DELETE`: `POST`
* `HEAD`: `GET`
* `OPTIONS`: `GET`

## Install

Via bower as `jquery-methodOverride`.

```sh
bower install --save jquery-methodOverride
```

## Usage

Include on your page, after jQuery. Supports AMD.

### Methods

The following methods will become available, which simultaneously support both `$.ajax` and `$.get`/`$.post` APIs.

```js
$.put(/* ... */);
$.patch(/* ... */);
$.delete(/* ... */);
$.head(/* ... */);
$.options(/* ... */);
```

For API details, refer to:
* [$.ajax](http://api.jquery.com/jQuery.ajax/)
* [$.get](http://api.jquery.com/jQuery.get/)
* [$.post](http://api.jquery.com/jQuery.post/)

### Forms

To enhance a form with method override, use `$.fn.methodOverride`.

#### Example

Given the following form:

```html
<form method="put">
  <!-- ... -->
</form>
```

And adding the following script:

```js
$('form').methodOverride();
```

Will result in the following enhanced form:

```html
<form method="POST" data-method-override="put">
  <!-- ... -->
  <input type="hidden" name="_method" value="put">
</form>
```

### Utility

* `$.fn.methodOverride.map`: `function (method:String) : String`

    Maps a method to its override method, if any.

* `$.fn.methodOverride.methods`: `Object.<String>`

    The raw object mapping methods to their override methods.

## Framework support

* [Ruby on Rails via `_method` parameter](http://guides.rubyonrails.org/form_helpers.html#how-do-forms-with-patch-put-or-delete-methods-work-questionmark)
* [Node.js Express/Connect via methodOverride](http://www.senchalabs.org/connect/methodOverride.html)
* more...

[RFC 2616]: http://www.ietf.org/rfc/rfc2616.txt


text:
<?php namespace Limoncello\Contracts\Http;

use Psr\Http\Message\ServerRequestInterface;

/**
 * @package Limoncello\Contracts
 */
interface RequestStorageInterface
{
    /**
     * @return ServerRequestInterface
     */
    public function get(): ServerRequestInterface;

    /**
     * @param ServerRequestInterface $request
     *
     * @return self
     */
    public function set(ServerRequestInterface $request): self;

    /**
     * @return bool
     */
    public function has(): bool;
}


text:
package org.linkedin.util.lang;

import org.linkedin.util.collections.CollectionsUtils;

import java.io.Serializable;
import java.util.EnumMap;
import java.util.EnumSet;

/**
 * This class represents memory size in terms of size and unit.
 * The size units supported range from bytes to tera bytes. Size
 * can be positive or negative. Instances of this class are immutable
 * and thread safe
 *
 * @author qsu
 *
 */
public class MemorySize implements Comparable<MemorySize>, Serializable
{
  private static final long serialVersionUID = 1L;
  public enum SizeUnit
  {
    // IMPORTANT: the order of enums below needs to be preserved
    // as from smallest to largest unit
    BYTE(1L, ""),
    KILO_BYTE(1024L * BYTE.getBytesCount(), "k"),
    MEGA_BYTE(1024L * KILO_BYTE.getBytesCount(), "m"),
    GIGA_BYTE(1024L * MEGA_BYTE.getBytesCount(), "g"),
    TERA_BYTE(1024L * GIGA_BYTE.getBytesCount(), "t");

    private final long   _bytesCount;
    private final String _displayChar;

    /**
     * Private constructor to ensure singleton for each enum type
     *
     * @param bytesCount
     * @param displayChar
     */
    private SizeUnit(long bytesCount, String displayChar)
    {
      _bytesCount = bytesCount;
      _displayChar = displayChar;
    }

    public long getBytesCount()
    {
      return _bytesCount;
    }

    public String getDisplayChar()
    {
      return _displayChar;
    }
  }

  public final static MemorySize                     ZERO_BYTES      = new MemorySize(0,
                                                                                SizeUnit.BYTE);
  public final static MemorySize                     ZERO_KILO_BYTES = new MemorySize(0,
                                                                                SizeUnit.KILO_BYTE);
  public final static MemorySize                     ZERO_MEGA_BYTES = new MemorySize(0,
                                                                                SizeUnit.MEGA_BYTE);
  public final static MemorySize                     ZERO_GIGA_BYTES = new MemorySize(0,
                                                                                SizeUnit.GIGA_BYTE);
  public final static MemorySize                     ZERO_TERA_BYTES = new MemorySize(0,
                                                                                SizeUnit.TERA_BYTE);

  /** a complete list of size units ordered descendingly */
  private final static SizeUnit[]                    ORDERED_SIZE_UNIT = CollectionsUtils.reverse(SizeUnit.values());

  private final static EnumMap<SizeUnit, MemorySize> ZERO_SIZES      = new EnumMap<SizeUnit, MemorySize>(SizeUnit.class);

  static
  {
    ZERO_SIZES.put(SizeUnit.BYTE, ZERO_BYTES);
    ZERO_SIZES.put(SizeUnit.KILO_BYTE, ZERO_KILO_BYTES);
    ZERO_SIZES.put(SizeUnit.MEGA_BYTE, ZERO_MEGA_BYTES);
    ZERO_SIZES.put(SizeUnit.GIGA_BYTE, ZERO_GIGA_BYTES);
    ZERO_SIZES.put(SizeUnit.TERA_BYTE, ZERO_TERA_BYTES);
  }

  private final long _size;
  private final SizeUnit _sizeUnit;

  /**
   * Constructor
   *
   * @param sizeInBytes
   */
  public MemorySize(long sizeInBytes)
  {
    this(sizeInBytes, SizeUnit.BYTE);
  }

  /**
   * Constructor
   *
   * @param size
   * @param sizeUnit
   */
  public MemorySize(long size, SizeUnit sizeUnit)
  {
    _size = size;
    _sizeUnit = sizeUnit;
  }

  public long getSize()
  {
    return _size;
  }

  public SizeUnit getSizeUnit()
  {
    return _sizeUnit;
  }

  /**
   * @return size in bytes
   */
  public long getSizeInBytes()
  {
    return getSize() * getSizeUnit().getBytesCount();
  }

  /**
   * @return size in kilo bytes, the remaining size if any istruncated
   */
  public long getSizeInKiloBytes()
  {
    return getSizeInBytes() / SizeUnit.KILO_BYTE.getBytesCount();
  }

  /**
   * @return size in mega bytes, the remaining size if any istruncated
   */
  public long getSizeInMegaBytes()
  {
    return getSizeInBytes() / SizeUnit.MEGA_BYTE.getBytesCount();
  }

  /**
   * @return size in giga bytes, the remaining size if any istruncated
   */
  public long getSizeInGigaBytes()
  {
    return getSizeInBytes() / SizeUnit.GIGA_BYTE.getBytesCount();
  }

  /**
   * @return size in tera bytes, the remaining size if any istruncated
   */
  public long getSizeInTeraBytes()
  {
    return getSizeInBytes() / SizeUnit.TERA_BYTE.getBytesCount();
  }

  /**
   * Return size in the given unit to floating point precision, useful when
   * truncating behavior is not desired
   *
   * @param sizeUnit
   * @return size in the given unit to floating point precision
   */
  public double getFractionalSize(SizeUnit sizeUnit)
  {
    return (double) getSizeInBytes() / sizeUnit.getBytesCount();
  }

  /**
   * Returns this memory size as a fractional size representation using the biggest unit size
   * possible. ex: 1.23g
   *
   * @return a string representing a this memory size as a fraction using the biggest size unit
   * possible
   */
  public String getFractionalSizeAsString()
  {
    if(_size == 0)
      return "0";

    long sizeInBytes = getSizeInBytes();

    // determine the biggest size unit with non 0 size
    for(SizeUnit sizeUnit : ORDERED_SIZE_UNIT)
    {
      if(sizeUnit == SizeUnit.BYTE)
        return String.valueOf(sizeInBytes);

      if(sizeInBytes >= sizeUnit.getBytesCount())
      {
        double fractionalSize = (double) sizeInBytes / sizeUnit.getBytesCount();
        return String.format("%.2f%s", fractionalSize, sizeUnit.getDisplayChar());
      }
    }

    throw new RuntimeException("should not reach this line...");
  }

  /**
   * Return a new instance of MemorySize that is truncated to the given unit
   *
   * @param sizeUnit
   * @return a new instance of MemorySize that is truncated to the given unit
   */
  public MemorySize truncate(SizeUnit sizeUnit)
  {
    if (getSizeUnit() == sizeUnit)
      return this;

    long sizeInBytes = getSizeInBytes();

    if (sizeInBytes >= sizeUnit.getBytesCount())
    {
      return new MemorySize(sizeInBytes / sizeUnit.getBytesCount(), sizeUnit);
    }
    else
    {
      return ZERO_SIZES.get(sizeUnit);
    }
  }

  /**
   * Return a new instance of MemorySize that adds up the size of this object
   * with that of the 'other'
   *
   * @param other
   * @return a new instance of MemorySize that adds up the size of this object
   * with the that of the 'other'
   */
  public MemorySize add(MemorySize other)
  {
    if(other == null)
      throw new NullPointerException();

    if(getSizeUnit() == other.getSizeUnit())
      return new MemorySize(getSize() + other.getSize(), getSizeUnit());

    return new MemorySize(getSizeInBytes() + other.getSizeInBytes(),
                        SizeUnit.BYTE);
  }

  /**
   * Return a new instance of MemorySize that subtract from this object
   * the size of the other object
   *
   * @param other
   * @return a new instance of MemorySize that subtract from this object
   * the size of the other object
   */
  public MemorySize subtract(MemorySize other)
  {
    if(other == null)
      throw new NullPointerException();

    if(getSizeUnit() == other.getSizeUnit())
      return new MemorySize(getSize() - other.getSize(), getSizeUnit());

    return new MemorySize(getSizeInBytes() - other.getSizeInBytes(),
                        SizeUnit.BYTE);
  }

  /**
   * Return a string representation of this instance using the given units
   * E.g. 2g3m4k given units g/m -> "2g3m"
   *      2g3m4k given units g/k -> "2g3076k"
   *        3m4k given units t/g -> "0g"
   *        2g3m given units k/b -> "2100224k"
   *
   * @param sizeUnits the sizeUnits you want in the decomposition
   * @return a string representation of this instance using the given units.
   */
  public String getAsString(SizeUnit...sizeUnits)
  {
    if(sizeUnits == null || sizeUnits.length == 0)
      return toString();

    return getAsString(CollectionsUtils.toEnumSet(SizeUnit.class, sizeUnits));
  }

  /**
   * Return a string representation of this instance using the given units
   * E.g. 2g3m4k given units g/m -> "2g3m"
   *      2g3m4k given units g/k -> "2g3076k"
   *        3m4k given units t/g -> "0g"
   *        2g3m given units k/b -> "2100224k"
   *
   * @param sizeUnits the sizeUnits you want in the decomposition
   * @return a string representation of this instance using the given units.
   */
  public String getAsString(EnumSet<SizeUnit> sizeUnits)
  {
    if(sizeUnits == null || sizeUnits.size() == 0)
      return toString();

    StringBuilder sb = new StringBuilder();
    MemorySize ms = this;
    MemorySize prevMs;

    // IMPORTANT:
    // according to javadoc for EnumSet:
    // "The iterator returned by the iteratormethod traverses the elements in their natural order
    // (the order in which the enum constants are declared)" and the toArray() method of AbstractCollection
    // guarantees such an order
    Object[] unitsAsArr = sizeUnits.toArray();

    int len = unitsAsArr.length;
    for (int i = len - 1; i > -1; i--)
    {
      prevMs = ms;
      ms = ms.truncate((SizeUnit)unitsAsArr[i]);
      if (ms.getSize() > 0)
      {
        sb.append(ms.getSize()).append(ms.getSizeUnit().getDisplayChar());
      }
      ms = prevMs.subtract(ms);
    }

    if(sb.length() == 0)
    {
      SizeUnit smallestUnit = (SizeUnit)unitsAsArr[0];
      sb.append("0").append(smallestUnit.getDisplayChar());
    }

    return sb.toString();
  }

  /**
   * Return a canonical representation of size where:
   * byte is < 1024, kilo byte is < 1024, mega byte is < 1024,
   * giga byte is < 1024, tera byte is < 1024.
   *
   * Unless it is representing the smallest unit, 0 size of a unit is not displayed
   *
   * @return canonical representation of size
   */
  public String getCanonicalString()
  {
    return getAsString(ORDERED_SIZE_UNIT);
  }

  /**
   * Return a canonical representation of size
   * see {@link #getCanonicalString()}
   *
   * @return canonical representation of size
   */
  @Override
  public String toString()
  {
    return getFractionalSizeAsString();
  }

  /**
   * Compare with another instance of MemorySize based on size in bytes
   *
   * @see java.lang.Comparable#compareTo(java.lang.Object)
   */
  @Override
  public int compareTo(MemorySize memorySize)
  {
    // according to javadoc for interface Comparable<T>, a NullPointerException
    // should be thrown when the object to be compared with is null
    // http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Comparable.html#compareTo(T)
    if (memorySize == null)
      throw new NullPointerException();

    if (getSizeUnit() == memorySize.getSizeUnit())
      return LangUtils.compare(getSize(), memorySize.getSize());

    return LangUtils.compare(getSizeInBytes(), memorySize.getSizeInBytes());
  }

  /**
   * Override java.lang.Object#equals(java.lang.Object)
   *
   * @return true if o is of class MemorySize and their size in bytes
   * are the same. Consistent with compareTo()
   */
  @Override
  public boolean equals(Object o)
  {
    if (this == o)
      return true;
    if (o == null || getClass() != o.getClass())
      return false;

    return compareTo((MemorySize) o) == 0;
  }

  /**
   * Override java.lang.Object#hashCode()
   *
   * @return hashCode of this object based on its size in byte
   */
  @Override
  public int hashCode()
  {
    long size = getSizeInBytes();
    return (int) (size ^ (size >>> 32));
  }

  /**
   * Create a new instance of MemorySize by adding up the given
   * array of memorySizes
   *
   * @param memorySizes
   * @return a new instance of MemorySize
   */
  public static MemorySize create(MemorySize...memorySizes)
  {
    if(memorySizes == null)
      return null;

    if(memorySizes.length == 0)
      return ZERO_BYTES;

    MemorySize res = memorySizes[0];

    for(int i = 1; i < memorySizes.length; i++)
    {
      MemorySize memorySize = memorySizes[i];
      if(memorySize != null)
        res = res.add(memorySize);
    }

    return res;
  }

  /**
   * Synonym...
   *
   * @param memorySizeAsStr
   * @return a new instance of MemorySize
   */
  public static MemorySize parse(String memorySizeAsStr)
  {
    return parseMemorySize(memorySizeAsStr);
  }

  /**
   * Create a new instance of MemorySize by parsing the given string
   * of format e.g. 2g3m4k5
   *
   * @param memorySizeAsStr
   * @return a new instance of MemorySize
   */
  public static MemorySize parseMemorySize(String memorySizeAsStr)
  {
    if(memorySizeAsStr == null || memorySizeAsStr.length() == 0)
      return null;

    int len = memorySizeAsStr.length();

    int orderedSizeUnitIdx = 0;
    int orderedSizeUnitLen = ORDERED_SIZE_UNIT.length;

    int startDigitsIdx = 0;
    boolean expectingDigits = true;

    MemorySize ms = ZERO_BYTES;
    for(int i = 0; i < len; i++)
    {
      char c = memorySizeAsStr.charAt(i);
      if(c >= '0' && c <= '9')
      {
        expectingDigits = false;
        continue;
      }

      if(expectingDigits)
        throw new IllegalArgumentException("Unable to parse '" + memorySizeAsStr + "': found '" + c
            + "' at pos " + i + ", was expecting a digit");

      for(; orderedSizeUnitIdx < orderedSizeUnitLen; orderedSizeUnitIdx++)
      {
        SizeUnit sizeUnit = ORDERED_SIZE_UNIT[orderedSizeUnitIdx];
        String displayChar = sizeUnit.getDisplayChar();

        if(displayChar.length() > 0 && c == displayChar.charAt(0))
        {
          try
          {
            long size = Long.parseLong(memorySizeAsStr.substring(startDigitsIdx, i));
            ms = ms.add(new MemorySize(size, sizeUnit));
            orderedSizeUnitIdx++;
            startDigitsIdx = i + 1;
            expectingDigits = true;
            break;
          }
          catch(NumberFormatException e)
          {
            throw new IllegalArgumentException("Unable to parse '" + memorySizeAsStr + "'", e);
          }
        }
      }

      if(orderedSizeUnitIdx == orderedSizeUnitLen)
        throw new IllegalArgumentException("Unable to parse '" + memorySizeAsStr
            + "': found invalid character '" + c + "' at pos " + i);
    }

    if(startDigitsIdx < len)
    {
      try
      {
        long size = Long.parseLong(memorySizeAsStr.substring(startDigitsIdx, len));
        ms = ms.add(new MemorySize(size, SizeUnit.BYTE));
      }
      catch(NumberFormatException e)
      {
        throw new IllegalArgumentException("Unable to parse '" + memorySizeAsStr + "'", e);
      }
    }
    return ms;
  }
}


text:
@interface DigitalPhaseLockedLoopBridge : NSObject

- (instancetype)initWithClocksPerBit:(NSUInteger)clocksPerBit;

- (void)runForCycles:(NSUInteger)cycles;
- (void)addPulse;

@property(nonatomic) NSUInteger stream;

@end


text:
function run_test() {
  var zReader = Components.classes["@mozilla.org/libjar/zip-reader;1"]
                        .createInstance(Components.interfaces.nsIZipReader);
  try {
    zReader.open(null);
    do_throw("Shouldn't get here!");
  } catch (e if (e instanceof Components.interfaces.nsIException &&
                 e.result == Components.results.NS_ERROR_NULL_POINTER)) {
    // do nothing, this test passes
  }
}


text:
class CreateCommands < ActiveRecord::Migration
  def change
    create_table :commands do |t|
      t.string :command
      t.integer :time
      t.integer :user_id

      t.timestamps
    end
  end
end


text:
namespace Werm.Abstractions
{
    using System.Net;

    public sealed class HttpListenerPrefixCollectionWrapper : IHttpListenerPrefixCollection
    {
        private readonly HttpListenerPrefixCollection prefixes;

        public HttpListenerPrefixCollectionWrapper(HttpListenerPrefixCollection prefixes)
        {
            this.prefixes = prefixes;
        }

        public void Add(string prefix)
        {
            this.prefixes.Add(prefix);
        }
    }
}


text:
using System.Collections.Generic;
using System.Linq;
using System.Web.Mvc;
using AspNetDeploy.Contracts;
using AspNetDeploy.Model;

namespace AspNetDeploy.WebUI.Controllers
{
    public class LogsController : AuthorizedAccessController
    {
        public LogsController(ILoggingService loggingService) : base(loggingService)
        {
        }

        public ActionResult List()
        {
            this.CheckPermission(UserRoleAction.ViewLogs);

            List<AspNetDeployExceptionEntry> aspNetDeployExceptionEntries = this.Entities.AspNetDeployExceptionEntry
                .Include("ExceptionEntry.InnerExceptionEntry")
                .Include("ExceptionEntry.ExceptionData")
                .Include("User")
                .OrderByDescending(ex => ex.TimeStamp)
                .Take(100)
                .ToList();

            this.ViewBag.AspNetDeployExceptionEntries = aspNetDeployExceptionEntries;

            return this.View();
        }

        public ActionResult Details(int id)
        {
            this.CheckPermission(UserRoleAction.ViewLogs);

            AspNetDeployExceptionEntry aspNetDeployExceptionEntry = this.Entities.AspNetDeployExceptionEntry
                .Include("ExceptionEntry.InnerExceptionEntry")
                .Include("ExceptionEntry.ExceptionData")
                .Include("User")
                .OrderByDescending(ex => ex.TimeStamp)
                .Take(100)
                .First( ex => ex.Id == id);

            this.ViewBag.aspNetDeployExceptionEntry = aspNetDeployExceptionEntry;

            return this.View();
        }
    }
}