Slic3r::Duet Class Reference

#include <src/slic3r/Utils/Duet.hpp>

Inheritance diagram for Slic3r::Duet:

Collaboration diagram for Slic3r::Duet:

Public Types
typedef Http::ProgressFn	ProgressFn
typedef std::function< void(wxString)>	ErrorFn
typedef std::function< void(wxString, wxString)>	InfoFn

Public Member Functions
	Duet (DynamicPrintConfig *config)
	~Duet () override=default
const char *	get_name () const override
bool	test (wxString &curl_msg) const override
wxString	get_test_ok_msg () const override
wxString	get_test_failed_msg (wxString &msg) const override
bool	upload (PrintHostUpload upload_data, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn) const override
bool	has_auto_discovery () const override
bool	can_test () const override
PrintHostPostUploadActions	get_post_upload_actions () const override
std::string	get_host () const override
virtual bool	supports_multiple_printers () const
virtual bool	get_groups (wxArrayString &) const
virtual bool	get_printers (wxArrayString &) const
virtual bool	get_storage (wxArrayString &, wxArrayString &) const

Static Public Member Functions
static PrintHost *	get_print_host (DynamicPrintConfig *config)

Protected Member Functions
virtual wxString	format_error (const std::string &body, const std::string &error, unsigned status) const

Private Types
enum class	ConnectionType { rrf , dsf , error }

Private Member Functions
std::string	get_upload_url (const std::string &filename, ConnectionType connectionType) const
std::string	get_connect_url (const bool dsfUrl) const
std::string	get_base_url () const
std::string	timestamp_str () const
ConnectionType	connect (wxString &msg) const
void	disconnect (ConnectionType connectionType) const
bool	start_print (wxString &msg, const std::string &filename, ConnectionType connectionType, bool simulationMode) const
int	get_err_code_from_body (const std::string &body) const

Private Attributes
std::string	host
std::string	password

Detailed Description

Member Typedef Documentation

ErrorFn

typedef std::function<void(wxString )> Slic3r::PrintHost::ErrorFn

inherited

InfoFn

typedef std::function<void(wxString , wxString )> Slic3r::PrintHost::InfoFn

inherited

ProgressFn

typedef Http::ProgressFn Slic3r::PrintHost::ProgressFn

inherited

Member Enumeration Documentation

ConnectionType

enum class Slic3r::Duet::ConnectionType

strongprivate

Enumerator
rrf
dsf
error

{ rrf, dsf, error };

Constructor & Destructor Documentation

Duet()

Slic3r::Duet::Duet ( DynamicPrintConfig *  config )

explicit

                                     :
  host(config->opt_string("print_host")),
  password(config->opt_string("printhost_apikey"))
{}

~Duet()

Slic3r::Duet::~Duet ( )

overridedefault

Member Function Documentation

can_test()

bool Slic3r::Duet::can_test ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return true; }

connect()

Duet::ConnectionType Slic3r::Duet::connect ( wxString &  msg ) const

private

{
  auto res = ConnectionType::error;
  auto url = get_connect_url(false);
 
  auto http = Http::get(std::move(url));
  http.on_error([&](std::string body, std::string error, unsigned status) {
      auto dsfUrl = get_connect_url(true);
      auto dsfHttp = Http::get(std::move(dsfUrl));
      dsfHttp.on_error([&](std::string body, std::string error, unsigned status) {
          BOOST_LOG_TRIVIAL(error) << boost::format("Duet: Error connecting: %1%, HTTP %2%, body: `%3%`") % error % status % body;
          msg = format_error(body, error, status);
        })
        .on_complete([&](std::string body, unsigned) {
          res = ConnectionType::dsf;
        })
        .perform_sync();
    })
    .on_complete([&](std::string body, unsigned) {
      BOOST_LOG_TRIVIAL(debug) << boost::format("Duet: Got: %1%") % body;
 
      int err_code = get_err_code_from_body(body);
      switch (err_code) {
        case 0:
          res = ConnectionType::rrf;
          break;
        case 1:
          msg = format_error(body, L("Wrong password"), 0);
          break;
        case 2:
          msg = format_error(body, L("Could not get resources to create a new connection"), 0);
          break;
        default:
          msg = format_error(body, L("Unknown error occured"), 0);
          break;
      }
 
    })
    .perform_sync();
 
  return res;
}

References dsf, error, Slic3r::PrintHost::format_error(), Slic3r::Http::get(), get_connect_url(), get_err_code_from_body(), L, and rrf.

Referenced by test(), and upload().

Here is the call graph for this function:

Here is the caller graph for this function:

disconnect()

void Slic3r::Duet::disconnect ( ConnectionType  connectionType ) const

private

{
  // we don't need to disconnect from DSF or if it failed anyway
  if (connectionType != ConnectionType::rrf) {
    return;
  }
  auto url =  (boost::format("%1%rr_disconnect")
      % get_base_url()).str();
 
  auto http = Http::get(std::move(url));
  http.on_error([&](std::string body, std::string error, unsigned status) {
    // we don't care about it, if disconnect is not working Duet will disconnect automatically after some time
    BOOST_LOG_TRIVIAL(error) << boost::format("Duet: Error disconnecting: %1%, HTTP %2%, body: `%3%`") % error % status % body;
  })
  .perform_sync();
}

References error, Slic3r::Http::get(), get_base_url(), and rrf.

Referenced by test(), and upload().

Here is the call graph for this function:

Here is the caller graph for this function:

format_error()

wxString Slic3r::PrintHost::format_error ( const std::string &  body, const std::string &  error, unsigned  status  ) const

protectedvirtualinherited

{
    if (status != 0) {
        auto wxbody = wxString::FromUTF8(body.data());
        return wxString::Format("HTTP %u: %s", status, wxbody);
    } else {
        return wxString::FromUTF8(error.data());
    }
}

References error.

Referenced by connect(), Slic3r::PrusaLink::post_inner(), Slic3r::PrusaLink::put_inner(), start_print(), Slic3r::AstroBox::test(), Slic3r::FlashAir::test(), Slic3r::Moonraker::test(), Slic3r::OctoPrint::test(), Slic3r::PrusaLink::test(), Slic3r::Repetier::test(), Slic3r::PrusaLink::test_with_method_check(), Slic3r::AstroBox::upload(), upload(), Slic3r::FlashAir::upload(), Slic3r::MKS::upload(), Slic3r::Moonraker::upload(), Slic3r::Repetier::upload(), and Slic3r::OctoPrint::upload_inner_with_host().

Here is the caller graph for this function:

get_base_url()

std::string Slic3r::Duet::get_base_url ( ) const

private

{
  if (host.find("http://") == 0 || host.find("https://") == 0) {
    if (host.back() == '/') {
      return host;
    } else {
      return (boost::format("%1%/") % host).str();
    }
  } else {
    return (boost::format("http://%1%/") % host).str();
  }
}

References host.

Referenced by disconnect(), get_connect_url(), get_upload_url(), and start_print().

Here is the caller graph for this function:

get_connect_url()

std::string Slic3r::Duet::get_connect_url ( const bool  dsfUrl ) const

private

{
  if (dsfUrl) {
    return (boost::format("%1%machine/status")
        % get_base_url()).str();
  } else {
    return (boost::format("%1%rr_connect?password=%2%&%3%")
        % get_base_url()
        % (password.empty() ? "reprap" : password)
        % timestamp_str()).str();
  }
}

References get_base_url(), password, and timestamp_str().

Referenced by connect().

Here is the call graph for this function:

Here is the caller graph for this function:

get_err_code_from_body()

int Slic3r::Duet::get_err_code_from_body ( const std::string &  body ) const

private

{
  pt::ptree root;
  std::istringstream iss (body); // wrap returned json to istringstream
  pt::read_json(iss, root);
 
  return root.get<int>("err", 0);
}

Referenced by connect(), and upload().

Here is the caller graph for this function:

get_groups()

virtual bool Slic3r::PrintHost::get_groups ( wxArrayString &  ) const

inlinevirtualinherited

Reimplemented in Slic3r::Repetier.

{ return false; }

get_host()

std::string Slic3r::Duet::get_host ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return host; }

References host.

get_name()

const char * Slic3r::Duet::get_name ( ) const

overridevirtual

Implements Slic3r::PrintHost.

{ return "Duet"; }

get_post_upload_actions()

PrintHostPostUploadActions Slic3r::Duet::get_post_upload_actions ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return PrintHostPostUploadAction::StartPrint | PrintHostPostUploadAction::StartSimulation; }

References Slic3r::StartPrint, and Slic3r::StartSimulation.

get_print_host()

PrintHost * Slic3r::PrintHost::get_print_host ( DynamicPrintConfig *  config )

staticinherited

{
    PrinterTechnology tech = ptFFF;
 
    {
        const auto opt = config->option<ConfigOptionEnum<PrinterTechnology>>("printer_technology");
        if (opt != nullptr) {
            tech = opt->value;
        }
    }
 
    if (tech == ptFFF) {
        const auto opt = config->option<ConfigOptionEnum<PrintHostType>>("host_type");
        const auto host_type = opt != nullptr ? opt->value : htOctoPrint;
 
        switch (host_type) {
            case htOctoPrint: return new OctoPrint(config);
            case htDuet:      return new Duet(config);
            case htFlashAir:  return new FlashAir(config);
            case htAstroBox:  return new AstroBox(config);
            case htRepetier:  return new Repetier(config);
            case htPrusaLink: return new PrusaLink(config);
            case htPrusaConnect: return new PrusaConnect(config);
            case htMKS:       return new MKS(config);
            case htMoonraker: return new Moonraker(config);
            default:          return nullptr;
        }
    } else {
        return new SL1Host(config);
    }
}

References Slic3r::htAstroBox, Slic3r::htDuet, Slic3r::htFlashAir, Slic3r::htMKS, Slic3r::htMoonraker, Slic3r::htOctoPrint, Slic3r::htPrusaConnect, Slic3r::htPrusaLink, Slic3r::htRepetier, Slic3r::ConfigBase::option(), Slic3r::ptFFF, and Slic3r::ConfigOptionSingle< T >::value.

Referenced by Slic3r::GUI::PhysicalPrinterDialog::build_printhost_settings(), Slic3r::GUI::PhysicalPrinterDialog::update_printers(), and Slic3r::GUI::PhysicalPrinterDialog::update_printhost_buttons().

Here is the call graph for this function:

Here is the caller graph for this function:

get_printers()

virtual bool Slic3r::PrintHost::get_printers ( wxArrayString &  ) const

inlinevirtualinherited

Reimplemented in Slic3r::Repetier.

{ return false; }

get_storage()

virtual bool Slic3r::PrintHost::get_storage ( wxArrayString &  , wxArrayString &    ) const

inlinevirtualinherited

Reimplemented in Slic3r::PrusaLink, and Slic3r::PrusaConnect.

{ return false; }

get_test_failed_msg()

wxString Slic3r::Duet::get_test_failed_msg ( wxString &  msg ) const

overridevirtual

Implements Slic3r::PrintHost.

{
    return GUI::format_wxstr("%s: %s", _L("Could not connect to Duet"), msg);
}

References _L, and Slic3r::GUI::format_wxstr().

Here is the call graph for this function:

get_test_ok_msg()

wxString Slic3r::Duet::get_test_ok_msg ( ) const

overridevirtual

Implements Slic3r::PrintHost.

{
  return _(L("Connection to Duet works correctly."));
}

References _, and L.

get_upload_url()

std::string Slic3r::Duet::get_upload_url ( const std::string &  filename, ConnectionType  connectionType  ) const

private

{
    assert(connectionType != ConnectionType::error);
 
  if (connectionType == ConnectionType::dsf) {
    return (boost::format("%1%machine/file/gcodes/%2%")
        % get_base_url()
        % Http::url_encode(filename)).str();
  } else {
    return (boost::format("%1%rr_upload?name=0:/gcodes/%2%&%3%")
        % get_base_url()
        % Http::url_encode(filename)
        % timestamp_str()).str();
  }
}

References dsf, error, get_base_url(), timestamp_str(), and Slic3r::Http::url_encode().

Referenced by upload().

Here is the call graph for this function:

Here is the caller graph for this function:

has_auto_discovery()

bool Slic3r::Duet::has_auto_discovery ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return false; }

start_print()

bool Slic3r::Duet::start_print ( wxString &  msg, const std::string &  filename, ConnectionType  connectionType, bool  simulationMode  ) const

private

{
    assert(connectionType != ConnectionType::error);
 
  bool res = false;
  bool dsf = (connectionType == ConnectionType::dsf);
 
  auto url = dsf
    ? (boost::format("%1%machine/code")
      % get_base_url()).str()
    : (boost::format(simulationMode
        ? "%1%rr_gcode?gcode=M37%%20P\"0:/gcodes/%2%\""
        : "%1%rr_gcode?gcode=M32%%20\"0:/gcodes/%2%\"")
      % get_base_url()
      % Http::url_encode(filename)).str();
 
  auto http = (dsf ? Http::post(std::move(url)) : Http::get(std::move(url)));
  if (dsf) {
    http.set_post_body(
        (boost::format(simulationMode
            ? "M37 P\"0:/gcodes/%1%\""
            : "M32 \"0:/gcodes/%1%\"")
          % filename).str()
        );
  }
  http.on_error([&](std::string body, std::string error, unsigned status) {
      BOOST_LOG_TRIVIAL(error) << boost::format("Duet: Error starting print: %1%, HTTP %2%, body: `%3%`") % error % status % body;
      msg = format_error(body, error, status);
    })
    .on_complete([&](std::string body, unsigned) {
      BOOST_LOG_TRIVIAL(debug) << boost::format("Duet: Got: %1%") % body;
      res = true;
    })
    .perform_sync();
 
  return res;
}

References dsf, error, Slic3r::PrintHost::format_error(), Slic3r::Http::get(), get_base_url(), Slic3r::Http::post(), and Slic3r::Http::url_encode().

Referenced by upload().

Here is the call graph for this function:

Here is the caller graph for this function:

supports_multiple_printers()

virtual bool Slic3r::PrintHost::supports_multiple_printers ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::Repetier.

{ return false; }

test()

bool Slic3r::Duet::test ( wxString &  curl_msg ) const

overridevirtual

Implements Slic3r::PrintHost.

{
  auto connectionType = connect(msg);
  disconnect(connectionType);
 
  return connectionType != ConnectionType::error;
}

References connect(), disconnect(), and error.

Here is the call graph for this function:

timestamp_str()

std::string Slic3r::Duet::timestamp_str ( ) const

private

{
  enum { BUFFER_SIZE = 32 };
 
  auto t = std::time(nullptr);
  auto tm = *std::localtime(&t);
 
  char buffer[BUFFER_SIZE];
  std::strftime(buffer, BUFFER_SIZE, "time=%Y-%m-%dT%H:%M:%S", &tm);
 
  return std::string(buffer);
}

Referenced by get_connect_url(), and get_upload_url().

Here is the caller graph for this function:

upload()

bool Slic3r::Duet::upload ( PrintHostUpload  upload_data, ProgressFn  prorgess_fn, ErrorFn  error_fn, InfoFn  info_fn  ) const

overridevirtual

Implements Slic3r::PrintHost.

{
  wxString connect_msg;
  auto connectionType = connect(connect_msg);
  if (connectionType == ConnectionType::error) {
    error_fn(std::move(connect_msg));
    return false;
  }
 
  bool res = true;
  bool dsf = (connectionType == ConnectionType::dsf);
 
  auto upload_cmd = get_upload_url(upload_data.upload_path.string(), connectionType);
  BOOST_LOG_TRIVIAL(info) << boost::format("Duet: Uploading file %1%, filepath: %2%, post_action: %3%, command: %4%")
    % upload_data.source_path
    % upload_data.upload_path
    % int(upload_data.post_action)
    % upload_cmd;
 
  auto http = (dsf ? Http::put(std::move(upload_cmd)) : Http::post(std::move(upload_cmd)));
  if (dsf) {
    http.set_put_body(upload_data.source_path);
  } else {
    http.set_post_body(upload_data.source_path);
  }
  http.on_complete([&](std::string body, unsigned status) {
      BOOST_LOG_TRIVIAL(debug) << boost::format("Duet: File uploaded: HTTP %1%: %2%") % status % body;
 
      int err_code = dsf ? (status == 201 ? 0 : 1) : get_err_code_from_body(body);
      if (err_code != 0) {
        BOOST_LOG_TRIVIAL(error) << boost::format("Duet: Request completed but error code was received: %1%") % err_code;
        error_fn(format_error(body, L("Unknown error occured"), 0));
        res = false;
      } else if (upload_data.post_action == PrintHostPostUploadAction::StartPrint) {
        wxString errormsg;
        res = start_print(errormsg, upload_data.upload_path.string(), connectionType, false);
        if (! res) {
          error_fn(std::move(errormsg));
        }
      } else if (upload_data.post_action == PrintHostPostUploadAction::StartSimulation) {
        wxString errormsg;
        res = start_print(errormsg, upload_data.upload_path.string(), connectionType, true);
        if (! res) {
          error_fn(std::move(errormsg));
        }
      }
    })
    .on_error([&](std::string body, std::string error, unsigned status) {
      BOOST_LOG_TRIVIAL(error) << boost::format("Duet: Error uploading file: %1%, HTTP %2%, body: `%3%`") % error % status % body;
      error_fn(format_error(body, error, status));
      res = false;
    })
    .on_progress([&](Http::Progress progress, bool &cancel) {
      prorgess_fn(std::move(progress), cancel);
      if (cancel) {
        // Upload was canceled
        BOOST_LOG_TRIVIAL(info) << "Duet: Upload canceled";
        res = false;
      }
    })
    .perform_sync();
 
  disconnect(connectionType);
 
  return res;
}

References connect(), disconnect(), dsf, error, Slic3r::PrintHost::format_error(), get_err_code_from_body(), get_upload_url(), L, Slic3r::Http::post(), Slic3r::PrintHostUpload::post_action, Slic3r::Http::put(), Slic3r::PrintHostUpload::source_path, start_print(), Slic3r::StartPrint, Slic3r::StartSimulation, and Slic3r::PrintHostUpload::upload_path.

Here is the call graph for this function:

Member Data Documentation

host

std::string Slic3r::Duet::host

private

Referenced by get_base_url(), and get_host().

password

std::string Slic3r::Duet::password

private

Referenced by get_connect_url().

---

The documentation for this class was generated from the following files:

• src/slic3r/Utils/Duet.hpp
• src/slic3r/Utils/Duet.cpp