Skip to content

S
socialshell
Commit 9f475c60 authored by Michael Murtaugh's avatar Michael Murtaugh
Browse files
Options

social shell 2018 updated for python 3.6

parent 4af2491c
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 128 additions and 635 deletions
NOTES deleted 100755 → 0
View file @ 4af2491c
(The machine stops)
* We (Anne + I) need to propose an alternative network.
** File collection of different kinds of materials
** Shared Keywording system
** Recipes reusable
* Can the architecture allow speculative / experimental
Speculative / Parody / Space
Nourrir
Provide
Our project provides documentation service
In the end, we want a working documentation...
Ideally, we want a document written
Systeem as writing spac
1984 Surveillance => 2014 Render service
We propose a "service" oriented system with all the problematics of Web 2.0
* Central,
* Truth, Authenticity...
* We watch, we make reports,
* We share the surveillance
* We invite users to hack the system
* Do we hide power relations, made explicit
(Specialist, Technical decisions, )
Hackable system
* Hot spot software ?
Surveillance systems
* Usage facebook
<!> Collect my HRO story
<!> Learn about setting up hot spot
CF: Eleanor Greenhalgh
* Milgram Experiment
* Kate Rich interview FSS
* Find the tone : We need to actually offer a service
NOTES FROM MEETING WITH ANNE
============================
Imaginative Cartography of the Shell
The Shell as a Fiction
Avoid Single Image Pipeline
Efficiency vs. Multiplicity
In both cases: sharing, serendipity, ... good things... but in what context and to what consequence
Frictionless Sharing:
* Hierarchical (Designed by designers, programmed by programmers, used by users, paid by advertisers)
* Automatic
* Consent out of context (one-time / pre-use consent through EULA / TOS)
* Shortest path, optimum solutions
vs.
Promiscuous Pipeline:
* Mixed roles (user becomes developer...)
* Hands on control
* Editability through interrogable
* Variability, multiplicity
Variability / Multiplicity:
like make can produce many versions / formats of output, an ideal promiscuous makefile would support a vast variety of possibilities
Granularity:
what's the smallest unit of "raw" material...
Recomposability:
How can the raw "units" be recombined / bound in new documents / frames / compilations
Examples:
Image + Caption
Q + A
Commit Message
==================================================
18 April 2014, Variable
==================================================
Parameters of time / space
instead of login.
(IP address, Authentication via password/email / OAUTH)
Imagine a network tagging time,
Location,
All activity is stored as a kind of relative map of nodes
REPORT
Playful: Make connections between people... introduce people to each other?
Return to the idea of sensing each others presence when working.
How do you give glimpses of others at work / encourage collaboration / spirit of working together in a digital enrivonment without devolving into full surveillance (watching every detail, etc).
RESPONSE TO THE "DATA NUDISM"
How to avoid the situation that providing a full report of logged activities, even when intended to warn, in fact comes very close to existing practices of "data nudism" -- ie providing self-surveillance as a service.
Stronger position is to propose alternative ways of working and active writing spaces (as opposed to passive logging) for people to explore collaboration and shift tracking to something explicit.
* Making the logs visible
Example: Typing a space in the terminal to prevent a message entering the history
[?] Core question: do we take a position of parody
KEY to actually propose a viable alternative
Scenario: People arrive for summer school, are handed a network pod...
immediately contrasts to tradition hotspot are apparent...
Etherpad + Anonymous contribution, time based //
(Nameless !== Anonymous)
Nameless, linking
Social File System //
alt git / distribute
Different set of handles for organizing & correlating data.
Proposing relations based on:
* Algorithmic (images with similar amounts of red)
*
Granularity
Recombination Modules
Examples
* Apple's Time Machine (based on the individual hard drive)
** non-collaboriative
* Internet archive wayback
** Based on the identity of the URL, )
** Limited by the parameters of the spider (ignoring some types of media, privileges a client-side view of the data)
** Follows nobot = noarchive
* Git
** Hash based identity (files are their content, not their name)
** Name + email
* Torrents
** Magnet link identity -- Distributed
Where the Social Network proposes relations based:
** Rejection of traditional authentication
**
** Algorithmic connections
* Share Canvas
Across different collaboration / file management tools:
* Identity (of people, of files, of digital content)
* Time
* Core stuctures for organizing / indexing
* Interface
Network / Access / Tactics of engagement (with existing...)
* Proxy, means of accessing existing systems (example of using github with other kinds of identity)
* Scroogle: Example of using a single account
* Publicizing one's login information
* Question of publishing
Relationality
* Setting in stone vs. Ad hoc relations
* Web ring, adding a link /// PYRING!
M commits an image
A commits a text
The commiters are sitting next to each other at the time & there's less than 5 seconds in time.
* SVG layers work
* http://www.yourworldoftext.com/
git + etherpad = shared canvas
a distributed space for files and ad hoc relationship
* Location
* Time
*
Multidimension space
* Relative timelines (not calendar / absolute)
* How to avoid the "sync-kill" (example of cinema)
* Shared index of files...
* Pre Summer School
* Summer School
* Post Summer School
Three temporalities of writing
* Prospective / Planning
* Real time / Happening Now
* Retrospective / Editing
Location, similary can be relevant / and can be not.
Ideally an interface for editing where one can "check in / check out" -- choose to detach.
* Timelines
* Spaces
* Tags
* yourworldoftext
* second life
* gray editor (julien maire)
* social/situated/cyberspace
IRC
Object as a clock / The chess clock
Example for prototyping futures:
* Using timelines to place / relate elements such as
* IRC as a protocol allows for distribution -- how does this work?
==================================================
index.html deleted 100755 → 0
View file @ 4af2491c
<!DOCTYPE html>
<html>
<head>
<title>socialshell</title>
<meta charset="utf-8" />
<script src="/lib/jquery-1.10.2.min.js"></script>
<link rel="stylesheet" type="text/css" href="styles.css">
<script type="text/javascript" src="script.js"></script>
</head>
<body>
<div>
$<input id="cmd" type="text" value="" />
<!-- <button id="start">start</button>
<button id="stop">stop</button>
<button id="manbutton">man</button>
<button id="cookbookbutton">cookbook</button>
--> </div>
<div class="bash" id="shell" style="width: 640px; float: left"></div>
<div id="man" class="bash" style="display: none;"></div>
</body>
</html>
lib/jquery-1.10.2.min.js deleted 100755 → 0
View file @ 4af2491c
This diff is collapsed.
script.js deleted 100755 → 0
View file @ 4af2491c
$(document).ready(function () {
/*
system as cookbook writing environment
hooks into repository manager for shared cookbook writing the (social)
+ hooks for realtime (chat?!)
Common problems:
Finally have got a working command, just want to save it
it's just awkward enough that you don't do it
(the effort of cut/paste, swapping to editor, naming and placing the file)
Instead: one-click "bookmarking", added to personal history list
Terminal is binary-averse (image, audio, visual material is "alienated" to external display)
HTML is "collage"-able means of mixing media
!! Pipeline editor / debugger with media-specific previews
* Bookmark (this command)
* Add to Recipe/Script
* Smart Tab completions
* Link to cookbook (examples)
separate stderr / stdout
script panes (editable!?)
man pages as postscript / pdf / savable?!
annotations in man pages <!>
mime type sniffing of output & appropriate browser-based display ( image / audio / video / text+html )
Missing features
* live programs / keyboard control (mplayer, top, etc...)
*/
$("#cmd")
.on("keypress", function (evt) {
console.log(evt);
if (evt.keyCode == 13) {
go();
} else if (evt.keyCode == 9) {
// tab
return false;
} else if (evt.charCode == 32) {
man();
} else if (evt.keyCode == 8) {
// Backspace
} else if (evt.keyCode == 38) {
// UP
} else if (evt.keyCode == 40) {
// DOWN
} else if (evt.keyCode == 37) {
// LEFT
} else if (evt.keyCode == 39) {
// RIGHT
} else if (evt.charCode == 92) {
// PIPE !
}
})
.focus();
function _sock (wsuri, opts) {
// to do add support for stderr, stdin & buffer data to ensure line-based processing callbacks for the two
// also set a flag for CR ?!
// might want to ensure closed before reopening a new one ?!
var that = {
sock: new WebSocket(wsuri)
},
curline = '';
that.close = function () {
that.sock.close();
}
that.sock.onopen = function(e) {
console.log("connected to " + wsuri);
if (opts.open) {
opts.open.call(that, e)
}
}
that.sock.onmessage = function (e) {
var lines = e.data.split(/([\n\r])/),
i,
len = lines.length;
if (len == 1) { // extend current line...
curline += lines[0];
} else {
for (i=0; i<len; i+=2) {
if (lines[i] == "") { continue; }
curline += lines[i];
opts.stdin.call(that, curline+lines[i+1]);
curline = "";
}
}
};
that.sock.onclose = function(e) {
console.log("connection closed (" + e.code + ")");
if (opts.close) { opts.close.call(that, e) };
}
return that;
}
var sock = null,
wsuri = "ws://localhost:9000",
lastline,
curline = '';
var shell = $("#shell").get(0);
function go () {
$(shell).text("");
sock = _sock(wsuri, {
open: function (e) { this.sock.send($("#cmd").val()); },
stdin: function (text) {
// console.log("message received: " + e.data);
var cr = text.match(/\r$/);
if (!cr || !lastline) {
lastline = $("<div></div>").appendTo(shell);
}
lastline.text(text)
},
close: function () {
console.log("closed");
}
});
}
function man() {
$("#man").addClass("loading").show();
var cmd = $("#cmd").val().split(/\s/)[0],
src = '';
console.log("cmd", cmd, "*");
$("#man").text("");
sock = _sock(wsuri, {
open: function (e) { this.sock.send("man -Thtml "+cmd); },
/* TODO: Hyperlink See Alsos !!! */
stdin: function (text) {
src += text;
// console.log("man");
},
close: function () {
console.log("man closed");
$("#man").html(src);
$("#man").removeClass("loading");
}
});
}
$("#stop").click(function () {
if (sock) {
sock.close();
sock = null;
}
})
});
serve.py deleted 100755 → 0
View file @ 4af2491c
#!/usr/bin/env python
import argparse, socket, os
import twisted
from time import sleep
from twisted.internet import reactor, protocol
from autobahn.twisted.websocket import WebSocketServerFactory, WebSocketServerProtocol, listenWS
from twisted.web.server import Site
from twisted.web.resource import Resource
from twisted.web.static import File
from twisted.web.twcgi import CGIDirectory
class AAWebSocketProtocol(WebSocketServerProtocol):
def __init__(self):
# WebSocketServerProtocol.__init__(self) # apparently there isn't one
self.process = None
def onMessage(self, msg, binary):
if (self.process == None):
self.process = AAProcessProtocol(self)
parts = msg.strip().split()
reactor.spawnProcess(self.process, parts[0], parts, {})
# self.sendMessage("Starting {0}...\n", False)
def onClose (self, wasclean, code, reason):
# web socket has closed, kill the process
print "web socket onClose", wasclean, code, reason
if (self.process != None):
self.process.kill()
self.process = None
def ended (self, code):
# process has ended (normally), close ourself
if (self.process != None):
# close outself
self.transport.loseConnection()
class AAProcessProtocol(protocol.ProcessProtocol):
def __init__(self, ws):
# self.output = ""
self.ws = ws
def connectionMade(self):
print "connectionMade"
self.transport.closeStdin() # no input to mplayer
def outReceived(self, data):
# print "outReceived, with %d bytes!" % len(data)
# self.output += data
self.ws.sendMessage(data, False)
def errReceived(self, data):
print "errReceived, with %d bytes!" % len(data)
print "<ERR>", data,
def inConnectionLost(self):
print "inConnectionLost, stdin is closed! (we probably did it)"
def outConnectionLost(self):
print "outConnectionLost! The child closed their stdout!"
# evt here code to (trigger) a processing of the output
def errConnectionLost(self):
print "errConnectionLost! The child closed their stderr."
def processExited(self, reason):
print "processExited, status %d" % (reason.value.exitCode,)
def processEnded(self, reason):
print "processEnded, status %d" % (reason.value.exitCode,)
self.ws.ended(reason.value.exitCode)
def kill (self):
# NOTES
# Here's the trace of a kill (when triggered by websocket.onClose)
# web socket onClose True None None
# errConnectionLost! The child closed their stderr.
# outConnectionLost! The child closed their stdout!
# processExited, status 1
# processEnded, status 1
# self.transport supports methods: write, closeStdin, closeStdout, closeStderr, loseConnection (close all 3)
# kill seems to cause errors while loseConnection closes things gracefully
# self.transport.signalProcess("KILL")
self.transport.loseConnection()
def main (args):
parser = argparse.ArgumentParser(description='Happy to serve you')
parser.add_argument('--port', type=int, default=8000, help='http port number')
parser.add_argument('--wsport', type=int, default=9000, help='websocket port number')
parser.add_argument('-t', '--notryports', default=True, action="store_false", help='if a port is busy, automatically try other ones')
parser.add_argument('--share', default=False, action="store_true", help='Run as server accessible via your local network')
args = parser.parse_args(args)
tryports = args.notryports
port = args.port
ipaddr = None
if args.share:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("wikipedia.org",80))
ipaddr = s.getsockname()[0]
interface = ipaddr # None would listen to all
s.close()
else:
interface = "localhost"
# HTTP
resource = File(".") # Resource()
# resource.putChild("f", File(cwd))
# resource.putChild("lib", File(activearchives.getDataPath("htdocs")))
# resource.putChild("cgi-bin", CGIDirectory(activearchives.getDataPath("cgi-bin")))
# resource.putChild("", File(activearchives.getDataPath("root/index.html")))
# resource.putChild("", File("."))
factory = Site(resource)
# WebSocket
wsfactory = WebSocketServerFactory("ws://localhost:{0}".format(args.wsport))
wsfactory.protocol = AAWebSocketProtocol
listenWS(wsfactory)
# reactor.run()
while True:
try:
if ipaddr:
server_address = (ipaddr, port)
servername = ipaddr
else:
server_address = ("", port)
servername = "localhost"
reactor.listenTCP(port, factory, interface=interface)
print "(Twisted) Archiving starts now --> http://{0}:{1}".format(servername, port)
reactor.run()
except twisted.internet.error.CannotListenError:
if tryports:
if port < 2000:
port = 2000
else:
port += 1
sleep(.01)
else:
print """
====================================
Error: port ({0}) is already in use
====================================
You can pick another port number
(for example 9999) with:
sosh --port 9999
""".format(port)
break
else:
raise(e)
if __name__ == "__main__":
import sys
main(sys.argv[1:])
socialshell.html 0 → 100644
View file @ 9f475c60
<!DOCTYPE html>
<html>
<head>
<title>social shell</title>
<meta charset="utf-8">
</head>
<body>
<input id="stdin" type="text" autofocus placeholder="$" >
<div id="stdout">
</div>
<script src="socialshell.js">
</script>
</body>
</html>
\ No newline at end of file
socialshell.js 0 → 100644
View file @ 9f475c60
(function () {
var stdin,
stdout,
sock;
window.addEventListener("DOMContentLoaded", function () {
console.log("loaded");
stdin = document.getElementById("stdin");
stdout = document.getElementById("stdout");
try { sock = new WebSocket('ws://' + window.location.host + '/ws'); }
catch(err) { sock = new WebSocket('wss://' + window.location.host + '/ws'); }
sock.onopen = function() {
console.log("sock.onopen");
};
sock.onmessage = function(event) {
// showMessage(event.data);
var msg = document.createElement("div");
msg.textContent = event.data;
stdout.appendChild(msg);
};
sock.onclose = function(event){
if(event.wasClean){
console.log('Clean connection end')
} else {
console.log('Connection broken')
}
};
sock.onerror = function(error){
console.log("error", error);
};
function enter () {
var val = stdin.value;
console.log("enter", val);
sock.send(val);
}
stdin.addEventListener("keydown", function (evt) {
if (evt.keyCode == 13) {
enter();
} else if (evt.keyCode == 9) {
// tab
return false;
} else if (evt.charCode == 32) {
man();
} else if (evt.keyCode == 8) {
// Backspace
} else if (evt.keyCode == 38) {
// UP
} else if (evt.keyCode == 40) {
// DOWN
} else if (evt.keyCode == 37) {
// LEFT
} else if (evt.keyCode == 39) {
// RIGHT
} else if (evt.charCode == 92) {
// PIPE !
}
})
});
})();
socialshell.py 0 → 100644
View file @ 9f475c60
import aiohttp
from aiohttp import web
import sys, asyncio
from asyncio import create_subprocess_shell
from asyncio.subprocess import DEVNULL, STDOUT, PIPE
async def socket_reader (ws):
async for msg in ws:
print(msg)
# if msg.data == 'close':
# await ws.close()
if msg.type == aiohttp.WSMsgType.TEXT:
print(msg.data)
cmd = msg.data
process = await create_subprocess_shell(cmd, stdin = DEVNULL, stdout=PIPE, stderr=STDOUT)
async for line in process.stdout:
# print ("gotline", line)
await ws.send_str(line.decode("utf-8"))
async def websocket_handler(request):
print('Websocket connection starting')
ws = web.WebSocketResponse()
await ws.prepare(request)
print('Websocket connection ready')
await socket_reader(ws)
print('Websocket connection closed')
return ws
def main ():
import argparse
ap = argparse.ArgumentParser("wwwsh")
args = ap.parse_args()
if sys.platform == 'win32':
# Folowing: https://docs.python.org/3/library/asyncio-subprocess.html
# On Windows, the default event loop is SelectorEventLoop which does not support subprocesses.
# ProactorEventLoop should be used instead.
loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(loop)
app = web.Application()
app.router.add_route('GET', '/', lambda request: web.FileResponse('./socialshell.html'))
app.router.add_route('GET', '/socialshell.js', lambda request: web.FileResponse('./socialshell.js'))
app.router.add_route('GET', '/ws', websocket_handler)
web.run_app(app)
if __name__ == "__main__":
main()
\ No newline at end of file
start deleted 100755 → 0
View file @ 4af2491c
#!/bin/bash
source venv/bin/activate
python serve.py
styles.css deleted 100755 → 0
View file @ 4af2491c
body, input {
margin: 10px;
font-family: monospace;
font-size: 16px;
background: #000;
color: white;
}
.bash {
font-family: monospace;
font-size: 12px;
height: 24em;
overflow: auto;
resize: both;
border: 1px dotted black;
}
#shell {
white-space: pre-wrap;
}
#cmd {
border: 1px solid black;
width: 640px;
}
.loading {
background: #AAA;
}
input#cmd {
border: none;
}
#man {
background: white;
padding: 10px;
color: black;
width: 400px;
float: left;
}
#man a {
color: purple;
text-decoration: none;
}
\ No newline at end of file