DistributedArnoldInterface.h

#ifndef _ArnoldDISTRIBUTED_INTERFACE_H_
#define _ArnoldDISTRIBUTED_INTERFACE_H_

#pragma once

#include "LumiverseCoreConfig.h"

#ifdef USE_ARNOLD
#ifdef USE_DUMIVERSE

#include <curl_easy.h>
#include <curl_exception.h>
#include <curl_form.h>
#include <zlib.h>
#include <algorithm>
#include <cstdio>
#include "ArnoldInterface.h"
#include "../lib/libjson/libjson.h"
#include <thread>
#include <iostream>
#include <locale>
#include <unordered_map>

// Apparently we need this to use zlib on windows to avoid windows being
// dumb and converting end-of-line characters for binary files
#if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(__CYGWIN__)
#  include <fcntl.h>
#  include <io.h>
#  define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
#else
#  define SET_BINARY_MODE(file)
#endif

#define CHUNK (1 << 17)
#define WINDOW_BITS 15
#define GZIP_ENCODING 16

namespace Lumiverse {

  struct RequestBuffer {
    char *buffer = NULL;
    size_t num_written = 0;
  };

  static size_t write_buffer_callback(void *ptr, size_t size, size_t nmemb, void *userdata);

  class DistributedArnoldInterface : public virtual ArnoldInterface
  {
  public:
    DistributedArnoldInterface(string host, int port, string outputPath) :
      ArnoldInterface(),
      m_host_name(host),
      m_host_port(port),
      m_file_output_path(outputPath),
      m_remote_open(false) {}

    DistributedArnoldInterface() :
      ArnoldInterface(),
      m_host_name("localhost"),
      m_host_port(80),
      m_file_output_path("./test.out"),
      m_remote_open(false) {}


    ~DistributedArnoldInterface() { }

    void init(const JSONNode jsonPatch);

    void close() override;

    bool setDims(int w, int h) override;
    
    void setSamples(int samples) override;

    virtual string getInterfaceType() { return "DistributedArnoldInterface"; }

    void setHostPort(long hostPort) { m_host_port = hostPort; };

    long getHostPort() { return m_host_port; };

    void setHostName(std::string hostName) { m_host_name = hostName; };

    std::string getHostName() { return m_host_name; };

    int render(const std::set<Device *> &devices);

    void interrupt() override;

    virtual float getPercentage() override;

    curl::curl_easy getCurlConnection() { return m_curl_connection; };

    std::string getFileOutputPath() { return m_file_output_path; };

    void setFileOutputPath(std::string outputPath) { m_file_output_path = outputPath; };

    void setOptionParameter(const std::string &paramName, int val) override;
    void setOptionParameter(const std::string &paramName, float val) override;

    bool isDistributedOpen() override;

  private:

    std::string m_host_name;

    long m_host_port;

    bool openConnection();

    bool sendDistributedInitRequest(const JSONNode jsonPatch);

    bool closeConnection();

    curl::curl_easy m_curl_connection;

    std::string m_file_output_path;

    bool deflateAss();

    void bindRequestBuffer(struct RequestBuffer *buffer, curl::curl_easy &curl_request);

    void bindRequestBuffer(struct RequestBuffer *buffer);

    bool remoteRequestSuccessful(JSONNode response);

    const JSONNode getDevicesJSON(const std::set<Device *> &devices);

    const JSONNode getSettingsJSON();

    // Maps containing global Arnold options node settings
    std::unordered_map<std::string, float> float_options;
    std::unordered_map<std::string, int> int_options;

    bool m_remote_open;
  };
}

#endif // USE_DUMIVERSE
#endif // USE_ARNOLD
#endif // _ArnoldDISTRIBUTED_INTERFACE_H_