OpenNebula

           src/cli/onenetworkfilter \

                           src/oca/ruby/OpenNebula/Networkfilter.rb \

                           src/oca/ruby/OpenNebula/NetworkfilterPool.rb \

                   src/cli/one_helper/onenetworkfilter_helper.rb \

               src/cli/onenetworkfilter \

                src/cli/etc/onenetworkfilter.yaml \

                    src/sunstone/models/OpenNebulaJSON/NetworkfilterJSON.rb \

        NETWORKFILTER   = 0x0000080000000000LL,

        ACL             = 0x0000100000000000LL

    /* added the NETWORKFILTER on 0x80000000000 and bumped ACL one down... */

            case NETWORKFILTER: return "NETWORKFILTER" ; break;

#include "NetworkfilterPool.h"

/* -------------------------------------------------------------------------- */

/* Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org)             */

/*                                                                            */

/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */

/* not use this file except in compliance with the License. You may obtain    */

/* a copy of the License at                                                   */

/*                                                                            */

/* http://www.apache.org/licenses/LICENSE-2.0                                 */

/*                                                                            */

/* Unless required by applicable law or agreed to in writing, software        */

/* distributed under the License is distributed on an "AS IS" BASIS,          */

/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */

/* See the License for the specific language governing permissions and        */

/* limitations under the License.                                             */

/* -------------------------------------------------------------------------- */

#ifndef NETWORKFILTER_POOL_H_

#define NETWORKFILTER_POOL_H_

#include "PoolSQL.h"

#include "Networkfilter.h"

#include "NebulaLog.h"

#include <time.h>

#include <sstream>

#include <iostream>

#include <vector>

class AuthRequest;

using namespace std;

/**

 *  The Networkfilter Pool class.

 */

class NetworkfilterPool : public PoolSQL

{

public:

    NetworkfilterPool(SqlDB *       db);

    ~NetworkfilterPool(){};

    /**

     *  Function to allocate a new Networkfilter object

     *    @param uid the user id of the Networkfilter's owner

     *    @param gid the id of the group this object is assigned to

     *    @param uname name of the user

     *    @param gname name of the group

     *    @param fw_template template associated with the Networkfilter

     *    @param oid the id assigned to the Networkfilter

     *    @param error_str Returns the error reason, if any

     *    @return the oid assigned to the object,

     *                  -1 in case of failure

     *                  -2 in case of template parse failure

     */

    int allocate (

        int              uid,

        int              gid,

        const string&    uname,

        const string&    gname,

        NetworkfilterTemplate * nf_template,

        int *            oid,

        string&          error_str);

    /**

     **  Function to get a Networkfilter from the pool, if the object is not in memory

     *  it is loaded from the DB

     *    @param oid Networkfilter unique id

     *    @param lock locks the Networkfilter mutex

     *    @return a pointer to the Networkfilter, 0 if the Networkfilter could not be loaded

     */

    Networkfilter * get(int oid, bool lock)

    {

        return static_cast<Networkfilter *>(PoolSQL::get(oid,lock));

    };

    /**

     *  Gets an object from the pool (if needed the object is loaded from the

     *  database).

     *   @param name of the object

     *   @param uid id of owner

     *   @param lock locks the object if true

     *

     *   @return a pointer to the object, 0 in case of failure

     */

    Networkfilter * get(const string& name, int uid, bool lock)

    {

        return static_cast<Networkfilter *>(PoolSQL::get(name,uid,lock));

    };

    /** 

     *  Update a particular Networkfilter

     *    @param image pointer to Networkfilter

     *    @return 0 on success

     */

    int update(Networkfilter * networkfilter)

    {

        return networkfilter->update(db);

    };

    //--------------------------------------------------------------------------

    // Virtual Network DB access functions

    //--------------------------------------------------------------------------

    /**

     *  Generates a NIC attribute for VM templates using the Networkfilter

     *  metadata

     *    @param nic the nic attribute to be generated

     *    @param vid of the VM requesting the Networkfilter

     *    @return 0 on success, 

     *            -1 error, 

     */

    int nic_attribute(VectorAttribute * nic, int uid, int vid);

    /**

     *  Bootstraps the database table(s) associated to the Networkfilter pool

     */

    static int bootstrap(SqlDB *_db)

    {

        return Networkfilter::bootstrap(_db);

    };

    /**

     *  Generates an Authorization token for the NETWORKFILTER attribute

     *    @param networkfilter the networkilter to be authorized

     *    @param uid of owner (to look for the networkfilter id within her images)

     *    @param ar the AuthRequest

     */

    void authorize_networkfilter(VectorAttribute * networkfilter, int uid, AuthRequest * ar);

    /**

     *  Dumps the Networkfilter pool in XML format. A filter can be also added to the

     *  query

     *  @param oss the output stream to dump the pool contents

     *  @param where filter for the objects, defaults to all

     *  @return 0 on success

     */

    int dump(ostringstream& oss, const string& where)

    {

        return PoolSQL::dump(oss, "NETWORKFILTER_POOL", Networkfilter::table, where);

    }

private:

    //--------------------------------------------------------------------------

    // Pool Attributes

    // -------------------------------------------------------------------------

    /**

     *  Factory method to produce Networkfilter objects

     *    @return a pointer to the new Networkfilter

     */

    PoolObjectSQL * create()

    {

        return new Networkfilter(-1,-1,"","",0);

    };

};

#endif /*NETWORKFILTER_POOL_H_*/

/* -------------------------------------------------------------------------- */

/* Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org)             */

/*                                                                            */

/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */

/* not use this file except in compliance with the License. You may obtain    */

/* a copy of the License at                                                   */

/*                                                                            */

/* http://www.apache.org/licenses/LICENSE-2.0                                 */

/*                                                                            */

/* Unless required by applicable law or agreed to in writing, software        */

/* distributed under the License is distributed on an "AS IS" BASIS,          */

/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */

/* See the License for the specific language governing permissions and        */

/* limitations under the License.                                             */

/* -------------------------------------------------------------------------- */

#ifndef REQUEST_MANAGER_NETWORKFILTER_H

#define REQUEST_MANAGER_NETWORKFILTER_H

#include "Request.h"

#include "Nebula.h"

using namespace std;

/* ------------------------------------------------------------------------- */

/* ------------------------------------------------------------------------- */

/* ------------------------------------------------------------------------- */

class RequestManagerNetworkfilter: public Request

{

protected:

    RequestManagerNetworkfilter( const string& method_name,

                            const string& help,

                            const string& params)

        :Request(method_name,params,help)

    {

        Nebula& nd  = Nebula::instance();

        pool        = nd.get_nfpool();

        auth_object = PoolObjectSQL::NETWORKFILTER;

        auth_op     = AuthRequest::MANAGE;

    };

    ~RequestManagerNetworkfilter(){};

    /* -------------------------------------------------------------------- */

    virtual void request_execute(xmlrpc_c::paramList const& _paramList,

                                 RequestAttributes& att) = 0;

};

/* ------------------------------------------------------------------------- */

/* ------------------------------------------------------------------------- */

class NetworkfilterEnable : public RequestManagerNetworkfilter

{

public:

    NetworkfilterEnable():

        RequestManagerNetworkfilter("NetworkfilterEnable",

                                   "Enables or disables a networkfilter",

                                   "A:sib"){};

    ~NetworkfilterEnable(){};

    void request_execute(xmlrpc_c::paramList const& _paramList,

                         RequestAttributes& att);

};

/* -------------------------------------------------------------------------- */

/* -------------------------------------------------------------------------- */

/* -------------------------------------------------------------------------- */

#endif

    NetworkfilterPool * get_nfpool()

    {

        return nfpool;

    };

        if ( nfpool != 0)

        {

            delete nfpool;

        }

    NetworkfilterPool  * nfpool;

#include "NetworkfilterTemplate.h"

class NetworkfilterAllocate: public RequestManagerAllocate

{

public:

    NetworkfilterAllocate():

        RequestManagerAllocate("NetworkfilterAllocate",

                               "Allocates a new networkfilter",

                               "A:ss",

                               true)

    {    

        Nebula& nd  = Nebula::instance();

        pool        = nd.get_nfpool();

        auth_object = PoolObjectSQL::NETWORKFILTER;

    };

    ~NetworkfilterAllocate(){};

    /* --------------------------------------------------------------------- */

    Template * get_object_template() 

    { 

        return new NetworkfilterTemplate; 

    };

    int pool_allocate(xmlrpc_c::paramList const& _paramList, 

                      Template * tmpl,

                      int& id, 

                      string& error_str,

                      RequestAttributes& att);

};

/* ------------------------------------------------------------------------- */

/* ------------------------------------------------------------------------- */

/* -------------------------------------------------------------------------- */

/* Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org)             */

/*                                                                            */

/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */

/* not use this file except in compliance with the License. You may obtain    */

/* a copy of the License at                                                   */

/*                                                                            */

/* http://www.apache.org/licenses/LICENSE-2.0                                 */

/*                                                                            */

/* Unless required by applicable law or agreed to in writing, software        */

/* distributed under the License is distributed on an "AS IS" BASIS,          */

/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */

/* See the License for the specific language governing permissions and        */

/* limitations under the License.                                             */

/* -------------------------------------------------------------------------- */

#ifndef NETWORKFILTER_TEMPLATE_H_

#define NETWORKFILTER_TEMPLATE_H_

#include "Template.h"

using namespace std;

/**

 *  Networkfilter Template class, it represents the attributes of a Host

 */

class NetworkfilterTemplate : public Template

{

public:

    NetworkfilterTemplate() : Template(false,'=',"TEMPLATE"){};

    ~NetworkfilterTemplate(){};

};

/* -------------------------------------------------------------------------- */

/* -------------------------------------------------------------------------- */

#endif /*NETWORKFILTER_TEMPLATE_H_*/

class NetworkfilterInfo: public RequestManagerInfo

{

public:

    NetworkfilterInfo():

        RequestManagerInfo("NetworkfilterInfo",

                           "Returns networkfilter information")

    {    

        Nebula& nd  = Nebula::instance();

        pool        = nd.get_nfpool();

        auth_object = PoolObjectSQL::NETWORKFILTER;

    };

    ~NetworkfilterInfo(){};

};

/* ------------------------------------------------------------------------- */

/* ------------------------------------------------------------------------- */

class NetworkfilterPoolInfo: public RequestManagerPoolInfoFilter

{

public:

    NetworkfilterPoolInfo():

        RequestManagerPoolInfoFilter("NetworkfilterPoolInfo",

                                     "Returns the networkfilter pool",

                                     "A:siii")

    {    

        Nebula& nd  = Nebula::instance();

        pool        = nd.get_nfpool();

        auth_object = PoolObjectSQL::NETWORKFILTER;

    };

    ~NetworkfilterPoolInfo(){};

};

/* -------------------------------------------------------------------------- */

/* -------------------------------------------------------------------------- */

/* ------------------------------------------------------------------------- */

/* ------------------------------------------------------------------------- */

class NetworkfilterChmod: public RequestManagerChmod

{

public:

    NetworkfilterChmod():

        RequestManagerChmod("NetworkfilterChmod",

                            "Changes permission bits of a networkfilter")

    {    

        Nebula& nd  = Nebula::instance();

        pool        = nd.get_nfpool();

        auth_object = PoolObjectSQL::NETWORKFILTER;

    };

    ~NetworkfilterChmod(){};

};

/* ------------------------------------------------------------------------ */

/* Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org)           */

/*                                                                          */

/* Licensed under the Apache License, Version 2.0 (the "License"); you may  */

/* not use this file except in compliance with the License. You may obtain  */

/* a copy of the License at                                                 */

/*                                                                          */

/* http://www.apache.org/licenses/LICENSE-2.0                               */

/*                                                                          */

/* Unless required by applicable law or agreed to in writing, software      */

/* distributed under the License is distributed on an "AS IS" BASIS,        */

/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */

/* See the License for the specific language governing permissions and      */

/* limitations under the License.                                           */

/* -------------------------------------------------------------------------*/

#ifndef NETWORKFILTER_H_

#define NETWORKFILTER_H_

#include "PoolSQL.h"

#include "NetworkfilterTemplate.h"

#include "NebulaLog.h"

using namespace std;

/**

 *  The Networkfilter class.

 */

class Networkfilter : public PoolObjectSQL

{

public:

    // *************************************************************************

    // Networkfilter Public Methods

    // *************************************************************************

    /**

     * Function to print the Networkfilter object into a string in XML format

     *  @param xml the resulting XML string

     *  @return a reference to the generated string

     */

    string& to_xml(string& xml) const;

    /**

     *  Rebuilds the object from an xml formatted string

     *    @param xml_str The xml-formatted string

     *

     *    @return 0 on success, -1 otherwise

     */

    int from_xml(const string &xml_str);

    /**

     *

     */

    int dec_running ()

    {

        return --running_vms;

    }

    /**

     *

     */

    int inc_running()

    {

        return ++running_vms;

    }

    /**

     *

     */

    int get_running()

    {

        return running_vms;

    }

    /**

     *  Check if the image can be used by other users

     *  @return true if group or others can access the image

     */

    bool isPublic()

    {

       return (group_u == 1 || other_u == 1); 

    }

    /**

     *  Factory method for networkfilter templates

     */

    Template * get_new_template()

    {

        return new NetworkfilterTemplate;

    }

    /**

     * Modifies the given nic attribute adding the filter attributes

     *  @param nic attribute for the VM template

     *  @param vid of the VM getting the lease

     *  @return 0 on success

     */

    int nic_attribute(VectorAttribute * nic, int vid);

private:

    // -------------------------------------------------------------------------

    // Friends

    // -------------------------------------------------------------------------

    friend class NetworkfilterPool;

    // -------------------------------------------------------------------------

    // Networkfilter Description

    // -------------------------------------------------------------------------

    /**

     *  Registration time

     */

    time_t       regtime;

    /**

     * Number of VMs using the image

     */

    int running_vms;

    // *************************************************************************

    // DataBase implementation (Private)

    // *************************************************************************

    /**

     *  Execute an INSERT or REPLACE Sql query.

     *    @param db The SQL DB

     *    @param replace Execute an INSERT or a REPLACE

     *    @return 0 on success

    */

    int insert_replace(SqlDB *db, bool replace, string& error_str);

    /**

     *  Bootstraps the database table(s) associated to the Networkfilter

     *    @return 0 on success

     */

    static int bootstrap(SqlDB * db)

    {

        ostringstream oss_networkfilter(Networkfilter::db_bootstrap);

        return db->exec(oss_networkfilter);

    };

    /**

     *  "Encrypts" the password with SHA1 digest

     *  @param password

     *  @return sha1 encrypted password

     */

    static string sha1_digest(const string& pass);

protected:

    // *************************************************************************

    // Constructor

    // *************************************************************************

    Networkfilter(int            uid,

             int            gid,

             const string&  uname,

             const string&  gname,

             NetworkfilterTemplate* fw_template);

    virtual ~Networkfilter();

    // *************************************************************************

    // DataBase implementation

    // *************************************************************************

    static const char * db_names;

    static const char * db_bootstrap;

    static const char * table;

    /**

     *  Writes the Networkfilter in the database.

     *    @param db pointer to the db

     *    @return 0 on success

     */

    virtual int insert(SqlDB *db, string& error_str);

    /**

     *  Writes/updates the Networkfilter data fields in the database.

     *    @param db pointer to the db

     *    @return 0 on success

     */

    virtual int update(SqlDB *db);

};

#endif /*Networkfilter_H_*/

class NetworkfilterDelete: public RequestManagerDelete

{

public:

    NetworkfilterDelete():

        RequestManagerDelete("NetworkfilterDelete", "Deletes a networkfilter")

    {    

        Nebula& nd  = Nebula::instance();

        pool        = nd.get_nfpool();

        auth_object = PoolObjectSQL::NETWORKFILTER;

    };

    ~NetworkfilterDelete(){};

};

/* ------------------------------------------------------------------------- */

/* ------------------------------------------------------------------------- */

     *  Releases all network filters taken by this Virtual Machine

     */

    void release_network_filters();

    /**

     *  the images and networks and networkfilters used

class NetworkfilterUpdateTemplate: public RequestManagerUpdateTemplate

{

public:

    NetworkfilterUpdateTemplate():

        RequestManagerUpdateTemplate("NetworkfilterUpdateTemplate",

                                     "Updates a networkfilter template")

    {    

        Nebula& nd  = Nebula::instance();

        pool        = nd.get_nfpool();

        auth_object = PoolObjectSQL::NETWORKFILTER;

    };

    ~NetworkfilterUpdateTemplate(){};

};

/* ------------------------------------------------------------------------- */

/* ------------------------------------------------------------------------- */

class NetworkfilterChown: public RequestManagerChown

{

public:

    NetworkfilterChown():

        RequestManagerChown("NetworkfilterChown",

                            "Changes ownership of an networkfilter")

    {    

        Nebula& nd  = Nebula::instance();

        pool        = nd.get_nfpool();

        auth_object = PoolObjectSQL::NETWORKFILTER;

    };

    ~NetworkfilterChown(){};

};

/* ------------------------------------------------------------------------- */

/* ------------------------------------------------------------------------- */

    cwd+'/src/networkfilter',

    'src/networkfilter/SConstruct',

            PoolObjectSQL::GROUP,

            PoolObjectSQL::NETWORKFILTER

    int objects_size = sizeof( objects ) / sizeof( objects[0] );

    for ( int i = 0; i < objects_size; i++ )

            vm->release_network_filters();

        vm->release_network_filters();

#include "NetworkfilterPool.h"

#include "Nebula.h"

    string  libvirt_filter;

    NetworkfilterPool * nfpool = Nebula::instance().get_nfpool();

    obj_template->get("LIBVIRT_FILTER",libvirt_filter);

    if (libvirt_filter != "")

    {

        nic->replace("LIBVIRT_FILTER",libvirt_filter);

    }

    // GET NETWORKFILTER NIC ATTRIBUTES

    rc = nfpool->nic_attribute(nic, uid, vid);

# -------------------------------------------------------------------------- #

# Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org)             #

#                                                                            #

# Licensed under the Apache License, Version 2.0 (the "License"); you may    #

# not use this file except in compliance with the License. You may obtain    #

# a copy of the License at                                                   #

#                                                                            #

# http://www.apache.org/licenses/LICENSE-2.0                                 #

#                                                                            #

# Unless required by applicable law or agreed to in writing, software        #

# distributed under the License is distributed on an "AS IS" BASIS,          #

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #

# See the License for the specific language governing permissions and        #

# limitations under the License.                                             #

#--------------------------------------------------------------------------- #

require 'OpenNebula/Pool'

module OpenNebula

    class NetworkfilterPool < Pool

        #######################################################################

        # Constants and Class attribute accessors

        #######################################################################

        NETWORKFILTER_POOL_METHODS = {

            :info => "networkfilterpool.info"

        }

        #######################################################################

        # Class constructor & Pool Methods

        #######################################################################

        # +client+ a Client object that represents a XML-RPC connection

        # +user_id+ is to refer to a Pool with Networkfilters from that user

        def initialize(client, user_id=-1)

            super('NETWORKFILTER_POOL','NETWORKFILTER',client)

            @user_id  = user_id

        end

        # Default Factory Method for the Pools

        def factory(element_xml)

            OpenNebula::Networkfilter.new(element_xml,@client)

        end

        #######################################################################

        # XML-RPC Methods for the Networkfilter Object

        #######################################################################

        # Retrieves all or part of the VirtualMachines in the pool.

        def info(*args)

            case args.size

                when 0

                    info_filter(NETWORKFILTER_POOL_METHODS[:info],@user_id,-1,-1)

                when 3

                    info_filter(NETWORKFILTER_POOL_METHODS[:info],args[0],args[1],args[2])

            end

        end

        def info_all()

            return super(NETWORKFILTER_POOL_METHODS[:info])

        end

        def info_mine()

            return super(NETWORKFILTER_POOL_METHODS[:info])

        end

        def info_group()

            return super(NETWORKFILTER_POOL_METHODS[:info])

        end

    end

end

    #                  NETWORKFILTER

            "GROUP"         => 0x40000000000,

            "NETWORKFILTER" => 0x80000000000

# -------------------------------------------------------------------------- #

# Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org)             #

#                                                                            #

# Licensed under the Apache License, Version 2.0 (the "License"); you may    #

# not use this file except in compliance with the License. You may obtain    #

# a copy of the License at                                                   #

#                                                                            #

# http://www.apache.org/licenses/LICENSE-2.0                                 #

#                                                                            #

# Unless required by applicable law or agreed to in writing, software        #

# distributed under the License is distributed on an "AS IS" BASIS,          #

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #

# See the License for the specific language governing permissions and        #

# limitations under the License.                                             #

#--------------------------------------------------------------------------- #

require 'OpenNebula/Pool'

require 'fileutils'

module OpenNebula

    class Networkfilter < PoolElement

        # ---------------------------------------------------------------------

        # Constants and Class Methods

        # ---------------------------------------------------------------------

        NETWORKFILTER_METHODS = {

            :info        => "networkfilter.info",

            :allocate    => "networkfilter.allocate",

            :update      => "networkfilter.update",

            :enable      => "networkfilter.enable",

            :delete      => "networkfilter.delete",

            :chown       => "networkfilter.chown",

            :chmod       => "networkfilter.chmod"

        }

        # Creates a Network filter description with just its identifier

        # this method should be used to create plain Network filter objects.

        # +id+ the id of the networkfilter

        #

        # Example:

        #   networkfilter = Networkfilter.new(Networkfilter.build_xml(3),rpc_client)

        #

        def Networkfilter.build_xml(pe_id=nil)

            if pe_id

                networkfilter_xml = "<NETWORKFILTER><ID>#{pe_id}</ID></NETWORKFILTER>"

            else

                networkfilter_xml = "<NETWORKFILTER></NETWORKFILTER>"

            end

            XMLElement.build_xml(networkfilter_xml,'NETWORKFILTER')

        end

        # Class constructor

        def initialize(xml, client)

            super(xml,client)

            @client = client

        end

        #######################################################################

        # XML-RPC Methods for the Network filter Object

        #######################################################################

        # Retrieves the information of the given Network filter.

        def info()

            super(NETWORKFILTER_METHODS[:info], 'NETWORKFILTER')

        end

        # Allocates a new Network filter in OpenNebula

        #

        # +description+ A string containing the template of the Network filter.

        def allocate(description)

            super(NETWORKFILTER_METHODS[:allocate],description)

        end

        # Replaces the template contents

        #

        # +new_template+ New template contents

        def update(new_template)

            super(NETWORKFILTER_METHODS[:update], new_template)

        end

        # Enables an Network filter

        def enable

            set_enabled(true)

        end

        # Disables an Network filter

        def disable

            set_enabled(false)

        end

        # Deletes the Network filter

        def delete()

            super(NETWORKFILTER_METHODS[:delete])

        end

        # Changes the owner/group

        # uid:: _Integer_ the new owner id. Set to -1 to leave the current one

        # gid:: _Integer_ the new group id. Set to -1 to leave the current one

        # [return] nil in case of success or an Error object

        def chown(uid, gid)

            super(NETWORKFILTER_METHODS[:chown], uid, gid)

        end

        # Changes the networkfilter permissions.

        #

        # @param octet [String] Permissions octed , e.g. 640

        # @return [nil, OpenNebula::Error] nil in case of success, Error

        #   otherwise

        def chmod_octet(octet)

            super(NETWORKFILTER_METHODS[:chmod], octet)

        end

        # Changes the networkfilter permissions.

        # Each [Integer] argument must be 1 to allow, 0 deny, -1 do not change

        #

        # @return [nil, OpenNebula::Error] nil in case of success, Error

        #   otherwise

        def chmod(owner_u, owner_m, owner_a, group_u, group_m, group_a, other_u,

                other_m, other_a)

            super(NETWORKFILTER_METHODS[:chmod], owner_u, owner_m, owner_a, group_u,

                group_m, group_a, other_u, other_m, other_a)

        end

        #######################################################################

        # Helpers to get Network filter information

        #######################################################################

        # Returns the group identifier

        # [return] _Integer_ the element's group ID

        def gid

            self['GID'].to_i

        end

    private

        def set_enabled(enabled)

            return Error.new('ID not defined') if !@pe_id

            rc = @client.call(NETWORKFILTER_METHODS[:enable], @pe_id, enabled)

            rc = nil if !OpenNebula.is_error?(rc)

            return rc

        end

        def set_publish(published)

            return Error.new('ID not defined') if !@pe_id

            rc = @client.call(NETWORKFILTER_METHODS[:publish], @pe_id, published)

            rc = nil if !OpenNebula.is_error?(rc)

            return rc

        end

    end

end

require 'OpenNebula/Networkfilter'

require 'OpenNebula/NetworkfilterPool'

/* -------------------------------------------------------------------------- */

/* Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org)             */

/*                                                                            */

/* Licensed under the Apache License, Version 2.0 (the "License"); you may    */

/* not use this file except in compliance with the License. You may obtain    */

/* a copy of the License at                                                   */

/*                                                                            */

/* http://www.apache.org/licenses/LICENSE-2.0                                 */

/*                                                                            */

/* Unless required by applicable law or agreed to in writing, software        */

/* distributed under the License is distributed on an "AS IS" BASIS,          */

/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */

/* See the License for the specific language governing permissions and        */

/* limitations under the License.                                             */

/* -------------------------------------------------------------------------- */

#include "RequestManagerNetworkfilter.h"

#include "Nebula.h"

/* -------------------------------------------------------------------------- */

/* -------------------------------------------------------------------------- */

void NetworkfilterEnable::request_execute(xmlrpc_c::paramList const& paramList,

                                 RequestAttributes& att)

{

    int     id      = xmlrpc_c::value_int(paramList.getInt(1));

    Networkfilter * networkfilter;

    NetworkfilterPool * nfpool = static_cast<NetworkfilterPool *>(pool);

    string error_str;

    if ( basic_authorization(id, att) == false )

    {

        return;

    }

    networkfilter = nfpool->get(id,true);

    if ( networkfilter  == 0 )

    {

        failure_response(NO_EXISTS,

                get_error(object_name(auth_object),id),

                att);

        return;

    }

    nfpool->update(networkfilter);

    networkfilter->unlock();

    success_response(id, att);

}

/* -------------------------------------------------------------------------- */

/* -------------------------------------------------------------------------- */

    'RequestManagerNetworkfilter.cc',

#include "RequestManagerNetworkfilter.h"

    xmlrpc_c::methodPtr networkfilter_update(new NetworkfilterUpdateTemplate());

    xmlrpc_c::methodPtr networkfilter_allocate(new NetworkfilterAllocate());

    xmlrpc_c::methodPtr networkfilter_delete(new NetworkfilterDelete());

    xmlrpc_c::methodPtr networkfilter_info(new NetworkfilterInfo());

    xmlrpc_c::methodPtr networkfilterpool_info(new NetworkfilterPoolInfo());

    xmlrpc_c::methodPtr networkfilter_chown(new NetworkfilterChown());

    xmlrpc_c::methodPtr networkfilter_chmod(new NetworkfilterChmod());

    /* Networkfilter related methods*/

    RequestManagerRegistry.addMethod("one.networkfilter.update", networkfilter_update);     

    RequestManagerRegistry.addMethod("one.networkfilter.allocate", networkfilter_allocate);

    RequestManagerRegistry.addMethod("one.networkfilter.delete", networkfilter_delete);

    RequestManagerRegistry.addMethod("one.networkfilter.info", networkfilter_info);

    RequestManagerRegistry.addMethod("one.networkfilter.chown", networkfilter_chown);

    RequestManagerRegistry.addMethod("one.networkfilter.chmod", networkfilter_chmod);

    RequestManagerRegistry.addMethod("one.networkfilterpool.info", networkfilterpool_info);

int NetworkfilterAllocate::pool_allocate(xmlrpc_c::paramList const& _paramList, 

                                 Template * tmpl,

                                 int& id, 

                                 string& error_str,

                                 RequestAttributes& att)

{

    NetworkfilterPool * nfpool = static_cast<NetworkfilterPool *>(pool);

    NetworkfilterTemplate * nftmpl = static_cast<NetworkfilterTemplate *>(tmpl);

    return nfpool->allocate(att.uid, att.gid, att.uname, att.gname, nftmpl, &id,

            error_str);

}

/* -------------------------------------------------------------------------- */

/* -------------------------------------------------------------------------- */

        case PoolObjectSQL::NETWORKFILTER:

            return "network filter";

    class NetworkfilterPoolJSON < OpenNebula::NetworkfilterPool; include JSONUtils; end

# -------------------------------------------------------------------------- #

# Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org)             #

#                                                                            #

# Licensed under the Apache License, Version 2.0 (the "License"); you may    #

# not use this file except in compliance with the License. You may obtain    #

# a copy of the License at                                                   #

#                                                                            #

# http://www.apache.org/licenses/LICENSE-2.0                                 #

#                                                                            #

# Unless required by applicable law or agreed to in writing, software        #

# distributed under the License is distributed on an "AS IS" BASIS,          #

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #

# See the License for the specific language governing permissions and        #

# limitations under the License.                                             #

#--------------------------------------------------------------------------- #

require 'OpenNebulaJSON/JSONUtils'

module OpenNebulaJSON

    class NetworkfilterJSON < OpenNebula::Networkfilter

        include JSONUtils

        def create(template_json)

            networkfilter_hash = parse_json(template_json, 'networkfilter')

            if OpenNebula.is_error?(networkfilter_hash)

                return networkfilter_hash

            end

            if networkfilter_hash['networkfilter_raw']

                template = networkfilter_hash['networkfilter_raw']

            else

                template = template_to_str(networkfilter_hash)

            end