This document discusses using an HTTP proxy to load specific web pages for testing purposes. It explains that many web pages contain resources from multiple domains that cannot be saved locally. An HTTP proxy can be used to intercept requests and redirect local URLs to a test server, while passing through external URLs to the actual web server. The document provides code examples for setting up an HTTP proxy using HTTP::Proxy and modifying the LWP user agent to handle local and remote URLs differently. Using this approach allows a test loop to load repeatable web page content from both local and external sources.
This talk was given at the Dutch PHP Conference 2011 and details the use of Comet (aka reverse ajax or ajax push) technologies and the importance of websockets and server-sent events. More information is available at http://joind.in/3237.
Ansible for beginners...? This presentation shows Ansible can not only Provisioning but also orchestration like capistrano or fabric. Module is super easy to create by not only Python like shell, Ruby and so on.
Docker images require appropriate shared object files (".so") to run. Rather than assume Ubuntu has the correct lib's, use ldd to get a list and install the ones you know you need. This can reduce the underlying images from GB to a few MB.
Despite advances in software design and static analysis techniques, software remains incredibly complicated and difficult to reason about. Understanding highly-concurrent, kernel-level, and intentionally-obfuscated programs are among the problem domains that spawned the field of dynamic program analysis. More than mere debuggers, the challenge of dynamic analysis tools is to be able record, analyze, and replay execution without sacrificing performance. This talk will provide an introduction to the dynamic analysis research space and hopefully inspire you to consider integrating these techniques into your own internal tools.
"Roles and Profiles" is now the ubiquitous design pattern to create your puppet code tree. In this talk we will discuss writing reusable and maintainable profiles. We ll start by introducing creating module structures and will move on to type hinting and setting appropriate defaults. Finally we ll discuss the importance and the enforcing of code style conventions that allows multiple teams or projects to inner-source profiless
This document outlines exercises for learning REST APIs with Python in 90 minutes. It introduces REST APIs and JSON format and how to make GET and POST requests using curl, requests module, and Python scripts. Exercises include making GET requests to retrieve headers and JSON data, handling HTTPS and basic authentication, and posting data to create a GitHub gist. The homework is to implement full CRUD operations for gists API, use OAuth for GitHub authentication, and get Jenkins job details in Python scripts.
You know how HTTP caching works but need more? In this talk we look into ways to cache personalized content. We will look at Edge Side Includes (ESI) to tailor caching rules of fragments, and at the user context concept to differentiate caches not by individual user but by permission groups.
Plack is a superglue for Perl web frameworks that provides a common interface called PSGI (Perl Web Server Gateway Interface) inspired by WSGI and Rack. PSGI allows any web application or framework to run on any web server by providing a standard way for applications to communicate with servers. Plack also includes tools like Plackup for running PSGI applications from the command line and middleware for common functionality that can be shared across frameworks. Many existing Perl web frameworks have been adapted to run under PSGI through Plack.
Pushing symfony events in real time to your clients This talk, held at the symfony live Paris unconference, gives an overview about how events thrown in symfony can be dispatched in real time to web clients. It describes the architecture of the solution and provides examples using the open source comet server APE
Webmock and VCR are tools for stubbing and recording HTTP requests in tests. Webmock allows fine-grained control over stubbing but requires the remote server, while VCR records and replays requests without the server through cassettes. The document provides information on setting up and using both tools to stub or record HTTP requests in different testing frameworks for reliable and isolated tests.
Puppet is an open source configuration management tool that can be used to automate the configuration and management of infrastructure and applications. It uses a client-server architecture and declarative language to define and enforce the desired state of systems. Other HashiCorp tools like Packer, Terraform, Vault and Nomad can integrate with Puppet for tasks like infrastructure provisioning, secrets management and workload orchestration. Bolt is a task orchestration tool from Puppet that can be used to automate operational tasks across infrastructure defined by tools like Terraform. Consul provides service discovery and configuration for the Puppet infrastructure.
This document discusses techniques for building scalable websites with Perl, including: 1) Caching at various levels (page, partial page, and database caching) to improve performance and reduce load on application servers. 2) Using job queuing and worker processes to distribute processing-intensive tasks asynchronously instead of blocking web requests. 3) Leveraging caching and queueing libraries like Cache::FastMmap, Memcached, and Spread::Queue to implement caching and job queueing in Perl applications.
Ansible is an IT automation tool that can provision and configure servers. It works by defining playbooks that contain tasks to be run on target servers. Playbooks use YAML format and modules to automate configuration changes. Vagrant and Ansible can be integrated so that Ansible playbooks are run as part of the Vagrant provisioning process to automate server setup. The document provides an introduction and examples of using Ansible playbooks with Vagrant virtual machines to install and configure the Apache HTTP server.
The document discusses Node.js and asynchronous I/O. It explains that Node.js is an asynchronous event-driven JavaScript runtime that uses a single-threaded model with non-blocking I/O to handle high volumes of simultaneous connections efficiently. It also discusses how Node.js handles asynchronous operations using an event loop and callback functions instead of blocking operations.
The document discusses practical web scraping using the Web::Scraper module in Perl. It provides an example of scraping the current UTC time from a website using regular expressions, then refactors it to use Web::Scraper for a more robust and maintainable approach. Key advantages of Web::Scraper include using CSS selectors and XPath to be less fragile, and proper handling of HTML encoding.
Node.js is an asynchronous event-driven JavaScript runtime that aims to provide an easy way to build scalable network programs. It uses an event loop model that keeps slow operations from blocking other operations by executing callbacks asynchronously. This allows Node.js programs to handle multiple connections concurrently without creating new threads. Common uses of Node.js include building web servers, real-time applications, crawlers, and process monitoring tools. The document provides examples of using modules like HTTP, TCP, DNS, and file system modules to demonstrate Node.js's asynchronous and non-blocking I/O model.
This document discusses integrating various HashiCorp tools like Packer, Vagrant, Terraform, Consul, and Vault with Icinga monitoring. Packer is used to build machine images while Vagrant provisions virtual machines. Terraform models infrastructure as code and can integrate with Icinga to provision hosts, checks, and notifications. Consul provides service discovery and can trigger Icinga config deployment. Vault manages secrets and certificates that could be used for authentication in Icinga. The presenter demonstrates using these tools together for infrastructure as code and monitoring workflows.
Short introduction to the basics of Perl testing and some resources for further reading. Includes basics of Test::Simple, Test::More, using Inline for multi-language testing, testing coverage, testing tests.
The document provides tips for reducing memory usage when working with Perl. It discusses how Perl handles memory for different data types like scalars, arrays, and hashes. Some key points made include: undef does not immediately free memory; recycling buffers within loops can help avoid unbounded growth; hashes are much larger than arrays so consider alternatives; and managing variable lifespans lexically can help reduce memory usage. The document provides various code examples and techniques for optimizing memory in Perl applications.
This document describes how to implement a stack trace handler for signals in Perl. It defines a subroutine called stack_trace that walks up the call stack using caller and prints each level. This subroutine is installed as the signal handler using $SIG. When a signal is received, stack_trace will be called and print out where in the code the signal occurred.
Plack is an interface for web request handlers that simplifies the interface and makes code more portable. It allows developers to focus on request handling rather than API specifics. Plack addresses issues with traditional CGI and mod_perl approaches by running handlers outside of servers in a standardized way. This encapsulation improves performance, debugging, and code reuse across different server implementations. Plack includes modules for common tasks like routing, middleware, and running PSGI applications on various web servers.
This document discusses the rise of social media and social influence marketing. It notes that social networks have reached widespread global penetration led by Facebook. It then outlines key social media activities like video watching and blogging across different regions. The document advocates developing a social influence marketing strategy that integrates paid, owned, and earned social media platforms and their measurement. It proposes measuring brand health through a social influence marketing score that considers the sentiment and reach of a brand on social media. Finally, it argues that successful marketing now requires adapting to the constant change of the digital environment through multiple, coherent messages rather than a singular consistent one.
Overview of Trampoline Objects in Perl with examples for lazy construction, lazy module use, added sanity checks. This version includes corrections from the original presented at OSCON 2013 and comments.
Come accedere al World Wide Web utilizzando Perl, dai primi passi ad un controllo avanzato sulle fasi di download e upload.
Mojolicious is a full-stack web framework and HTTP client for Perl that provides an object-oriented API without hidden magic or dependencies. It includes features like asynchronous I/O, routing, plugins, sessions, templating, internationalization support, and JSON/XML handling. Mojolicious comes in three flavors: Mojolicious::Lite for simple apps, Mojolicious for full MVC apps, and Mojo as a lightweight base framework. It supports technologies like CGI, FastCGI, PSGI, HTTP 1.1, and WebSockets.
This document discusses asynchronous PHP processing and libraries. It begins with an overview of synchronous vs asynchronous processing and blocking vs non-blocking I/O. It then reviews several approaches for asynchronous PHP including Pthreads, pcntl_fork, popen, curl_multi, and event loops with libraries like ReactPHP. ReactPHP is discussed in depth as an event-driven non-blocking I/O library that uses promises and streams for asynchronous operations. Examples are provided for asynchronous HTTP requests, DNS lookups, and a pub/sub application using ZeroMQ. Key points emphasized are that asynchronous code does not necessarily run faster and execution order is not guaranteed.
Mojo started as an alternative to the aging LWP library for HTTP requests in Perl. It was created by Sebastian Riedel to have a more modern, asynchronous API. Mojo provides an easy to use and full-featured HTTP client and server with support for features like websockets, parallel requests, and more. The library uses a test-driven development approach and strives to have a pragmatic design with reusable components.