TODO : Implement Root-fs extraction

This is a simple mock containerization tool written in Go. It mimics the behavior of basic container operations like pulling an image, unpacking it, and running commands within a new namespace. This tool does not fully replicate Docker’s functionality but provides a lightweight alternative for educational purposes.

• Pull Docker images and save them as tar.gz archives.
• Unpack the archives and run commands within new namespaces.
• Use cgroups to limit resources.
• Chroot to the unpacked image root filesystem.

1. run: Run a command inside a new container.

   ./cnts run <image> <command>

   Example:

   ./cnts run ubuntu /bin/sh

2. child: This is an internal command used by run. It sets up the new namespaces and executes the command.

3. pull: Pull a Docker image and store it as a tar.gz archive.

   ./cnts pull <image>

   Example:

   ./cnts pull ubuntu

The pull script is a helper bash script to fetch Docker images, export their filesystem, and save it to the assets directory.

#!/bin/bash

set -e

defaultImage="hello-world"

image="${1:-$defaultImage}"
container=$(docker create "$image")

docker export "$container" -o "./assets/${image}.tar.gz" > /dev/null
docker rm "$container" > /dev/null

docker inspect -f '{{.Config.Cmd}}' "$image:latest" | tr -d '[]\n' > "./assets/${image}-cmd"

echo "Image content stored in assets/${image}.tar.gz"

1. Build the Go program:

   go build -o cnts

2. Make the pull script executable:

   chmod +x pull

3. Use the commands as described above.

Note: You need to run these commands as root:

root@device:~# ./cnts run <image> <command>
root@device:~# ./cnts pull <image>

This tool is for educational purposes and is not intended for production use. It demonstrates basic containerization concepts like namespaces and cgroups without the complexity and features of full-fledged container runtimes like Docker.

This repository is divided into repositories 1a, 1b, 2 and 3. Through this project a glassfish application that connects to a postgres sql database and that it is deployed through different linux machines will be developed and its performance meausured, tested and improved.

Throug repository 1a I start getting in touch with elements of the JAVA EE architecture, to a multitier system(GUI, application and RDBMs). The application developed uses JSP, Servlets and JavaBeans. It is also used JDBC to connect to the database. In this first repository I also work throught the technology of Web Services and automatitation of work and deploy with ant.

Through repository1b I keep understanding the insights of the JAVA EE architecture. I work through the business logic through EJBs session stateless. I also work through queue manager and API JMS for the communication between JAVA EE applications. Also I work through the Message Driven Beans(MDBs).

Through repository 2, the performace of the JAVA EE application is measured. I work through aspects of performance in JAVA EE applications, influence of the configuration of the server of applications in the performance, processing chain within the application server, elements that compose it, glue points, obtaining the productivity curve, application server configuration for performance, performance evaluation mechanisms and unit tests and stress tests of a JAVA EE application: automation of a test plan with the JMETER tool.

Through repository 3, it is reviewed general aspects of clustering, configuration of a cluster, implementation of a secure cluster and availability tests of a J2EE application.

A GNOME Shell extension that lets you customize and enhance your GNOME Shell UX to suit your workflow, whether you like horizontally or vertically stacked workspaces.

Currently supported GNOME versions: 42 – 48.
The main branch, which always contains the most recent version, supports GNOME 45–48. New features and optimizations are backported to the gnome-42-44 branch with a delay.

• Supports both vertically and horizontally stacked workspaces
• Customizable overview layout, appearance and behavior
• Customizable secondary monitor overview
• Enhanced overview keyboard navigation and control supporting secondary monitors
• Static overview modes minimize unnecessary screen content movement
• Optional hot corner/edge position
• Customizable panel visibility
• Customizable app grid and app folders – icon size, dimensions, sorting, active folder previews
• Customizable dash – icon size, appearance and behavior, workspace isolation, click and scroll actions
• Customizable search – results width, number of results, improved searching
• Customizable workspace switcher – static background
• Notification and OSD positions and behavior
• Window attention handler behavior
• Customizable Super key behavior
• Keyboard and mouse shortcuts allow advanced workspace and window control
• 4 predefined and fully customizable profiles

This section explains some of the less obvious and invisible additions to the Shell’s behavior.

If you’re using a mouse, you can open the app grid directly by clicking the Activities button with the secondary mouse button.

V-Shell lets you choose which corner opens the Activities overview. You can also make the whole edge of the screen work as a trigger. This can be set in Hot Corner > Position on the Behavior tab of the Settings window. The Follow Dash option picks the corner closest to the first icon in the Dash. The Follow Dash - Hot Edge option makes the whole screen edge where the Dash is active. Be aware that the hot edge may block the mouse pointer from accessing the secondary monitor.

V-Shell fixes the Tab key navigation and adds more hotkeys to control windows and workspaces

V-Shell enhances the default app search by adding categories and executables from app launchers to the search sources, while prioritizing app names.

V-Shell provides an option to include GNOME Settings panels in the app results, making them more quickly accessible than through the separate list box.

You can use two dots (..) before a search query to isolate system functions included in the app search results – for example, type ..log, ..out, or even ..g to access the logout dialog. Or type the dots and select the desired function using tha Tab key or arrow keys.

If you activate an app icon while holding the Shift key, all of its windows will be moved to the current workspace. This works also for Dash icons.

The default V-Shell configuration features a searchable app grid, allowing you to filter its content, including app folders, simply by typing when the app grid view is active. It delivers the same results as the default app search but without the constraint of the search view width. Additionally, V-Shell can search for apps by categories embedded in their launchers, making it easy to find all system, game, internet, or video applications. This functionality minimizes the need for manually organizing apps into visual categories.

To enhance the efficiency of the application menu when using the mouse, V-Shell offers the Active Icons in Folder Preview option. When enabled, icons in the folder preview (folder icon) behave like regular app icons, allowing users to interact with them without opening the folder. V-Shell allows you to increase the number of icons in the preview from 4 to 9, as well as adjust the size of the app grid icons. This feature enables the folder icons to divide the main app grid into sections, with the most frequently used apps readily accessible while others remain hidden deeper within folders.

Simply drag-and-drop folder onto a workspace thumbnail to open all containing applications.

The default GNOME Shell configuration includes predefined shortcuts for workspaces oriented in both axis: (Shift)+Ctrl+Alt+ Arrow Keys and for horizontal only: (Shift)+Super+PageUp/Down

The default GNOME Settings application only offers options to configure keyboard shortcuts for horizontally oriented workspaces. However, the gSettings configuration scheme provides keys for shortcuts for vertically oriented workspaces as well. You can access and configure these shortcuts using the dconf Editor.

When V-Shell is configured to use vertically stacked workspaces, the (Shift)+Super+PageUp/Down shortcuts for switching workspaces stop working. V-Shell provides the option Override Page Up/Down Shortcuts to automatically switch the default Super+PageUp/Down and Shift+Super+PageUp/Down shortcuts for the current workspace orientation. If enabled, this option will move the shortcuts between following gSettings keys:

Note that unlike the GNOME Settings application, dconf Editor allows you to add more than one keyboard shortcut to each action. V-Shell preserves all other shortcuts, only moves following strings between related gSetting keys:

• <Super>Page_Up
• <Super>Page_Down
• <Super><Shift>Page_Up
• <Super><Shift>Page_Down

The key order follows the order in which GNOME Settings stores the shortcuts. If you add the same shortcut but with a different key order, V-Shell will not recognize it, and you might end up with the same shortcut assigned to two actions.

V-Shell overrides parts of the GNOME Shell’s UI code, and many extensions do the same, so conflicts are inevitable. V-Shell tries to mitigate the consequences of conflicts with the most popular extensions, which includes disabling its own modules. This means that some of V-Shell’s settings may not function when conflicting extensions are enabled. V-Shell also provides manual control over its modules so the user can disable problematic ones if needed.

Please, report any incompatibility, you encounter while using V-Shell.

to prevent crashes upon GNOME Shell starting up:

• Dash to Dock
• Ubuntu Dock
• Dash to Panel
• Dash2Dock Animated

You can enable this option manually if needed, using the Delay at Startup option on the Misc tab of the Settings window.

and should be disabled or restricted by the user:

• Partially Blur My Shell – V-Shell provides a basic settings for the overview background, including brightness and blur effects. If you want to use Blur My Shell, consider disabling its options for the overview, including app folders, to prevent visual glitches and inconsistency during transitions between overview states.
• Alphabetical App Grid – V-Shell provides much more options than alphabetical sorting
• Grand Theft Focus and other extensions preventing showing notification instead of immediately focusing the window that demands attention
• Hot Edge – V-Shell provides this functionality as an option of the Hot Corner Position setting
• Some of the Just Perfection options including overview elements visibility and size, notifications/OSD positions, hiding main panel, animation speed, and more
• Impatience and extensions adjusting animation speed
• Click to close overview – V-Shell provides the Click Empty Space To Close option

See what’s changed in recent versions CHANGELOG.md

The easiest way to install the latest stable release of V-Shell: go to extensions.gnome.org and toggle the switch.

Download the latest release archive using following command:

wget https://github.com/G-dH/vertical-workspaces/releases/latest/download/vertical-workspaces@G-dH.github.com.zip

Install the extension (--force switch needs to be used only if some version of the extension is already installed):

gnome-extensions install --force vertical-workspaces@G-dH.github.com.zip

The most recent version in the repository is the one I’m currently using and developing on my own systems, problems may occur, but usually nothing serious. The repository version may change often and doesn’t updates automatically on your system. If you want to help me, use this latest version and report bugs. You may need to install git, make, gettext and glib2.0 for successful installation. Navigate to the directory you want to download the source code and execute following commands in the terminal:

GNOME 45+:

git clone https://github.com/G-dH/vertical-workspaces.git
cd vertical-workspaces
make install

GNOME 42 – 44:

git clone https://github.com/G-dH/vertical-workspaces.git
cd vertical-workspaces
git checkout gnome-42-44
make install

If you get Can't recursively copy directory error, take a look at issue #51.

After installation you need to enable the extension and access its settings.

• First restart GNOME Shell (ALt + F2, r, Enter, or Log Out/Log In if you use Wayland)
• Now you should see Vertical Workspaces extension in Extensions application (re-open the app if needed to load new data), where you can enable it and access its Preferences window by pressing Settings button.

V-Shell contains modified GNOME Shell source code and was originally based on parts of Vertical Overview extension.

If you want to help with V-Shell development, please provide feedback, whether it’s positive, negative, a bug report, or a feature request. Even if I don’t agree with you, it can help improve V-Shell.

If you enjoy using my extensions, you can help me with my coffee expenses:

Any support is greatly appreciated!

This program is distributed under the terms of the GNU General Public License, version 3 or later. See LICENSE file for details.

Rails is a web-application framework that includes everything needed to create database-backed web applications according to the Model-View-Control pattern.

This pattern splits the view (also called the presentation) into “dumb” templates that are primarily responsible for inserting pre-built data in between HTML tags. The model contains the “smart” domain objects (such as Account, Product, Person, Post) that holds all the business logic and knows how to persist themselves to a database. The controller handles the incoming requests (such as Save New Account, Update Product, Show Post) by manipulating the model and directing data to the view.

In Rails, the model is handled by what’s called an object-relational mapping layer entitled Active Record. This layer allows you to present the data from database rows as objects and embellish these data objects with business logic methods. You can read more about Active Record in files/vendor/rails/activerecord/README.html.

The controller and view are handled by the Action Pack, which handles both layers by its two parts: Action View and Action Controller. These two layers are bundled in a single package due to their heavy interdependence. This is unlike the relationship between the Active Record and Action Pack that is much more separate. Each of these packages can be used independently outside of Rails. You can read more about Action Pack in files/vendor/rails/actionpack/README.html.

1. At the command prompt, create a new Rails application:

   <tt>rails new myapp</tt> (where <tt>myapp</tt> is the application name)

2. Change directory to myapp and start the web server:

   <tt>cd myapp; rails server</tt> (run with --help for options)

3. Go to localhost:3000/ and you’ll see:

   "Welcome aboard: You're riding Ruby on Rails!"
   

4. Follow the guidelines to start developing your application. You can find

the following resources handy:

• The Getting Started Guide: guides.rubyonrails.org/getting_started.html

• Ruby on Rails Tutorial Book: www.railstutorial.org/

Sometimes your application goes wrong. Fortunately there are a lot of tools that will help you debug it and get it back on the rails.

First area to check is the application log files. Have “tail -f” commands running on the server.log and development.log. Rails will automatically display debugging and runtime information to these files. Debugging info will also be shown in the browser on requests from 127.0.0.1.

You can also log your own messages directly into the log file from your code using the Ruby logger class from inside your controllers. Example:

class WeblogController < ActionController::Base
  def destroy
    @weblog = Weblog.find(params[:id])
    @weblog.destroy
    logger.info("#{Time.now} Destroyed Weblog ID ##{@weblog.id}!")
  end
end

The result will be a message in your log file along the lines of:

Mon Oct 08 14:22:29 +1000 2007 Destroyed Weblog ID #1!

More information on how to use the logger is at www.ruby-doc.org/core/

Also, Ruby documentation can be found at www.ruby-lang.org/. There are several books available online as well:

• Programming Ruby: www.ruby-doc.org/docs/ProgrammingRuby/ (Pickaxe)

• Learn to Program: pine.fm/LearnToProgram/ (a beginners guide)

These two books will bring you up to speed on the Ruby language and also on programming in general.

Debugger support is available through the debugger command when you start your Mongrel or WEBrick server with –debugger. This means that you can break out of execution at any point in the code, investigate and change the model, and then, resume execution! You need to install ruby-debug to run the server in debugging mode. With gems, use sudo gem install ruby-debug. Example:

class WeblogController < ActionController::Base
  def index
    @posts = Post.all
    debugger
  end
end

So the controller will accept the action, run the first line, then present you with a IRB prompt in the server window. Here you can do things like:

>> @posts.inspect
=> "[#<Post:0x14a6be8
        @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>,
     #<Post:0x14a6620
        @attributes={"title"=>"Rails", "body"=>"Only ten..", "id"=>"2"}>]"
>> @posts.first.title = "hello from a debugger"
=> "hello from a debugger"

…and even better, you can examine how your runtime objects actually work:

>> f = @posts.first
=> #<Post:0x13630c4 @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>
>> f.
Display all 152 possibilities? (y or n)

Finally, when you’re ready to resume execution, you can enter “cont”.

The console is a Ruby shell, which allows you to interact with your application’s domain model. Here you’ll have all parts of the application configured, just like it is when the application is running. You can inspect domain models, change values, and save to the database. Starting the script without arguments will launch it in the development environment.

To start the console, run rails console from the application directory.

Options:

• Passing the -s, --sandbox argument will rollback any modifications made to the database.

• Passing an environment name as an argument will load the corresponding environment. Example: rails console production.

To reload your controllers and models after launching the console run reload!

More information about irb can be found at: http://www.rubycentral.org/pickaxe/irb.html

You can go to the command line of your database directly through rails dbconsole. You would be connected to the database with the credentials defined in database.yml. Starting the script without arguments will connect you to the development database. Passing an argument will connect you to a different database, like rails dbconsole production. Currently works for MySQL, PostgreSQL and SQLite 3.

The default directory structure of a generated Ruby on Rails application:

|-- app
|   |-- assets
|   |   |-- images
|   |   |-- javascripts
|   |   `-- stylesheets
|   |-- controllers
|   |-- helpers
|   |-- mailers
|   |-- models
|   `-- views
|       `-- layouts
|-- config
|   |-- environments
|   |-- initializers
|   `-- locales
|-- db
|-- doc
|-- lib
|   |-- assets
|   `-- tasks
|-- log
|-- public
|-- script
|-- test
|   |-- fixtures
|   |-- functional
|   |-- integration
|   |-- performance
|   `-- unit
|-- tmp
|   `-- cache
|       `-- assets
`-- vendor
    |-- assets
    |   |-- javascripts
    |   `-- stylesheets
    `-- plugins

app

Holds all the code that's specific to this particular application.

app/assets

Contains subdirectories for images, stylesheets, and JavaScript files.

app/controllers

Holds controllers that should be named like weblogs_controller.rb for
automated URL mapping. All controllers should descend from
ApplicationController which itself descends from ActionController::Base.

app/models

Holds models that should be named like post.rb. Models descend from
ActiveRecord::Base by default.

app/views

Holds the template files for the view that should be named like
weblogs/index.html.erb for the WeblogsController#index action. All views use
eRuby syntax by default.

app/views/layouts

Holds the template files for layouts to be used with views. This models the
common header/footer method of wrapping views. In your views, define a layout
using the <tt>layout :default</tt> and create a file named default.html.erb.
Inside default.html.erb, call <% yield %> to render the view using this
layout.

app/helpers

Holds view helpers that should be named like weblogs_helper.rb. These are
generated for you automatically when using generators for controllers.
Helpers can be used to wrap functionality for your views into methods.

config

Configuration files for the Rails environment, the routing map, the database,
and other dependencies.

db

Contains the database schema in schema.rb. db/migrate contains all the
sequence of Migrations for your schema.

doc

This directory is where your application documentation will be stored when
generated using <tt>rake doc:app</tt>

lib

Application specific libraries. Basically, any kind of custom code that
doesn't belong under controllers, models, or helpers. This directory is in
the load path.

public

The directory available for the web server. Also contains the dispatchers and the
default HTML files. This should be set as the DOCUMENT_ROOT of your web
server.

script

Helper scripts for automation and generation.

test

Unit and functional tests along with fixtures. When using the rails generate
command, template test files will be generated for you and placed in this
directory.

vendor

External libraries that the application depends on. Also includes the plugins
subdirectory. If the app has frozen rails, those gems also go here, under
vendor/rails/. This directory is in the load path.

erdantic is a simple tool for drawing entity relationship diagrams (ERDs) for Python data model classes. Diagrams are rendered using the Graphviz library. Supported data modeling frameworks are:

• Pydantic V2
• Pydantic V1 legacy
• attrs
• msgspec
• dataclasses from the Python standard library

You can use erdantic either as a convenient CLI or as a Python library. Great for adding a simple and clean data model reference to your documentation.

Type annotations are formatted using the typenames library.

erdantic’s graph modeling depends on pygraphviz and Graphviz, an open-source C library. If you are on Linux or macOS, the easiest way to install everything together is to use conda and conda-forge:

conda install erdantic -c conda-forge

If not using conda, Graphviz must be installed first (before you can install pygraphviz). For recommended options and installation troubleshooting, see the pygraphviz docs. Then to install erdantic and its Python dependencies from PyPI:

pip install erdantic

You can get the development version from GitHub with:

pip install "erdantic @ git+https://github.com/drivendataorg/erdantic.git"

See pip’s documentation for more on how to specify VCS dependencies.

First, make sure that the data model classes that you want to include in your diagram are importable. This means the code with your models should either be available on your sys.path or installed into the same virtual environment as erdantic.

The fastest way to produce a diagram like the above example is to use the erdantic CLI. Simply specify the full dotted import path to your model and an output file path. The rendered format is interpreted from the filename extension.

erdantic erdantic.examples.pydantic.Party -o diagram.png

You can also import the erdantic Python library. This lets you inspect the diagram data and potentially modify it. You will have greater ability to customize the diagram in Python.

import erdantic as erd
from erdantic.examples.pydantic import Party

# Easy one-liner
erd.draw(Party, out="diagram.png")

# Or create a diagram object that you can inspect and do stuff with
diagram = erd.create(Party)
list(diagram.models.keys())
#> [ 'erdantic.examples.pydantic.Adventurer',
#>   'erdantic.examples.pydantic.Party',
#>   'erdantic.examples.pydantic.Quest',
#>   'erdantic.examples.pydantic.QuestGiver']
diagram.draw("diagram.png")

Check out the “Usage Examples” section of our docs to see more.

This bot will monitor skins of your choice, and then purchase them automatically. At the moment it works only with CHROMIUM BASED BROWSERS! This bot will not work with stickers and cases, keep this in mind. (You can check what is planned at the bottom of README). Also consider that I’m working on this project alone, so there’s a chance that something won’t work as it should. If you find a bug, open a ticket in the issue and I’ll try to fix it.

• Skin monitoring
• Automatic purchase
• Logging into file after purchase
• You can choose specific patterns or floats for bot to find
• Buy only skins with/without stickers
• You can set max price for skin
• You can set max pages to look for

Selenium, PyYAML, Requests, chromedriver-autoinstaller

pip install -r /path/to/requirements.txt

Open settinngs/config.yaml file ,and fill this file based on example provided.

# Example configuration file for program

skins:
  - url: https://steamcommunity.com/market/listings/730/MP7%20%7C%20Army%20Recon%20%28Field-Tested%29
    float: # Leave empty for ANY
    price: 100 
    number_of_stickers: # Leave empty for ANY
    pages: 2
    pattern: 502, 800
  - url: https://steamcommunity.com/market/listings/730/UMP-45%20%7C%20Urban%20DDPAT%20%28Factory%20New%29
    float: 
    price: 
    number_of_stickers:
    pages: 2
    pattern: 123

Then, start the program

python csgo-market-sniper.py

Chrome window with steam login page will open. LOGIN INTO STEAM FIRST!

• Setting to buy higher than set float skin, not lower only.
• Buy stickers, cases, agents etc.

🕹 Simple NPM package interface to the Mojang API

$ npm i minecraft_head

You can find Documentation here

const mc = require('minecraft_head'); // Import Module
let player = new mc.player('Sigma76'); // Create a new Player (Can use Name or Uuid)

// Will take Player Object or player name as a string
mc.nameToUuid(player)
    .then(data => {
        console.log(data.uuid);
    })
    .catch(console.log);

// Another way if using player Object
player.uuid.then(uuid => {
    console.log(uuid);
});

// Will take player Object or Uuid as a string
mc.uuidToName(player)
    .then(data => {
        console.log(data.name);
    })
    .catch(console.log);

// Another way if using player Object
player.name.then(name => {
    console.log(name);
});

// Will take Player Object or Uuid as a string
mc.getNameHistory(player)
    .then(data => {
        console.log(data);
    })
    .catch(console.log);

// Will take Player Object or Uuid as a string
// Also takes a Date Object
// Due to API limitations anything before the first name change will be the accounts original name.
mc.getNameAtDate(player, new Date('2017-01-01'))
    .then(name => {
        console.log(name);
    })
    .catch(console.log);

// Will take Player Object or Uuid as a string
// Before the Player Object you would need to convert a player name to Uuid yourself
mc.getSkin(player)
    .then(skin => {
        console.log(skin);
    })
    .catch(console.log);

mc.isServerBlocked('playmc.mx')
    .then(data => {
        console.log(data);
    })
    .catch(console.log);